From bba62c3754bab836d75db85f1bd1bdff980fb9ad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?M=C3=A1rk=20S=C3=A1gi-Kaz=C3=A1r?= Date: Wed, 15 Sep 2021 18:03:44 +0200 Subject: [PATCH] all: rewrite tests to use testify instead of goconvey (#300) --- file_test.go | 392 +++++------ helper_test.go | 12 +- ini_python_multiline_test.go | 46 +- ini_test.go | 1252 ++++++++++++++++++---------------- key_test.go | 578 ++++++++-------- parser_test.go | 46 +- section_test.go | 254 +++---- struct_test.go | 425 ++++++------ 8 files changed, 1531 insertions(+), 1474 deletions(-) diff --git a/file_test.go b/file_test.go index 9a70d5e..836a0d7 100644 --- a/file_test.go +++ b/file_test.go @@ -20,53 +20,51 @@ import ( "runtime" "testing" - . "github.com/smartystreets/goconvey/convey" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "gopkg.in/ini.v1" ) func TestEmpty(t *testing.T) { - Convey("Create an empty object", t, func() { - f := ini.Empty() - So(f, ShouldNotBeNil) + f := ini.Empty() + require.NotNil(t, f) - // Should only have the default section - So(len(f.Sections()), ShouldEqual, 1) + // Should only have the default section + assert.Len(t, f.Sections(), 1) - // Default section should not contain any key - So(len(f.Section("").Keys()), ShouldBeZeroValue) - }) + // Default section should not contain any key + assert.Len(t, f.Section("").Keys(), 0) } func TestFile_NewSection(t *testing.T) { - Convey("Create a new section", t, func() { - f := ini.Empty() - So(f, ShouldNotBeNil) + f := ini.Empty() + require.NotNil(t, f) - sec, err := f.NewSection("author") - So(err, ShouldBeNil) - So(sec, ShouldNotBeNil) - So(sec.Name(), ShouldEqual, "author") + sec, err := f.NewSection("author") + require.NoError(t, err) + require.NotNil(t, sec) + assert.Equal(t, "author", sec.Name()) - So(f.SectionStrings(), ShouldResemble, []string{ini.DefaultSection, "author"}) + assert.Equal(t, []string{ini.DefaultSection, "author"}, f.SectionStrings()) - Convey("With duplicated name", func() { - sec, err := f.NewSection("author") - So(err, ShouldBeNil) - So(sec, ShouldNotBeNil) + t.Run("with duplicated name", func(t *testing.T) { + sec, err := f.NewSection("author") + require.NoError(t, err) + require.NotNil(t, sec) - // Does nothing if section already exists - So(f.SectionStrings(), ShouldResemble, []string{ini.DefaultSection, "author"}) - }) + // Does nothing if section already exists + assert.Equal(t, []string{ini.DefaultSection, "author"}, f.SectionStrings()) + }) - Convey("With empty string", func() { - _, err := f.NewSection("") - So(err, ShouldNotBeNil) - }) + t.Run("with empty string", func(t *testing.T) { + _, err := f.NewSection("") + require.Error(t, err) }) } func TestFile_NonUniqueSection(t *testing.T) { - Convey("Read and write non-unique sections", t, func() { + t.Run("read and write non-unique sections", func(t *testing.T) { f, err := ini.LoadSources(ini.LoadOptions{ AllowNonUniqueSections: true, }, []byte(`[Interface] @@ -81,21 +79,21 @@ AllowedIPs = 192.168.2.2/32 [Peer] PublicKey = AllowedIPs = 192.168.2.3/32`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) sec, err := f.NewSection("Peer") - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) _, _ = sec.NewKey("PublicKey", "") _, _ = sec.NewKey("AllowedIPs", "192.168.2.4/32") var buf bytes.Buffer _, err = f.WriteTo(&buf) - So(err, ShouldBeNil) + require.NoError(t, err) str := buf.String() - So(str, ShouldEqual, `[Interface] + assert.Equal(t, `[Interface] Address = 192.168.2.1 PrivateKey = ListenPort = 51820 @@ -112,10 +110,10 @@ AllowedIPs = 192.168.2.3/32 PublicKey = AllowedIPs = 192.168.2.4/32 -`) +`, str) }) - Convey("Delete non-unique section", t, func() { + t.Run("delete non-unique section", func(t *testing.T) { f, err := ini.LoadSources(ini.LoadOptions{ AllowNonUniqueSections: true, }, []byte(`[Interface] @@ -136,17 +134,17 @@ PublicKey = AllowedIPs = 192.168.2.4/32 `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) err = f.DeleteSectionWithIndex("Peer", 1) - So(err, ShouldBeNil) + require.NoError(t, err) var buf bytes.Buffer _, err = f.WriteTo(&buf) - So(err, ShouldBeNil) + require.NoError(t, err) str := buf.String() - So(str, ShouldEqual, `[Interface] + assert.Equal(t, `[Interface] Address = 192.168.2.1 PrivateKey = ListenPort = 51820 @@ -159,223 +157,209 @@ AllowedIPs = 192.168.2.2/32 PublicKey = AllowedIPs = 192.168.2.4/32 -`) +`, str) }) - Convey("Delete all sections", t, func() { + t.Run("delete all sections", func(t *testing.T) { f := ini.Empty(ini.LoadOptions{ AllowNonUniqueSections: true, }) - So(f, ShouldNotBeNil) + require.NotNil(t, f) _ = f.NewSections("Interface", "Peer", "Peer") - So(f.SectionStrings(), ShouldResemble, []string{ini.DefaultSection, "Interface", "Peer", "Peer"}) + assert.Equal(t, []string{ini.DefaultSection, "Interface", "Peer", "Peer"}, f.SectionStrings()) f.DeleteSection("Peer") - So(f.SectionStrings(), ShouldResemble, []string{ini.DefaultSection, "Interface"}) + assert.Equal(t, []string{ini.DefaultSection, "Interface"}, f.SectionStrings()) }) } func TestFile_NewRawSection(t *testing.T) { - Convey("Create a new raw section", t, func() { - f := ini.Empty() - So(f, ShouldNotBeNil) + f := ini.Empty() + require.NotNil(t, f) - sec, err := f.NewRawSection("comments", `1111111111111111111000000000000000001110000 + sec, err := f.NewRawSection("comments", `1111111111111111111000000000000000001110000 111111111111111111100000000000111000000000`) - So(err, ShouldBeNil) - So(sec, ShouldNotBeNil) - So(sec.Name(), ShouldEqual, "comments") - - So(f.SectionStrings(), ShouldResemble, []string{ini.DefaultSection, "comments"}) - So(f.Section("comments").Body(), ShouldEqual, `1111111111111111111000000000000000001110000 -111111111111111111100000000000111000000000`) - - Convey("With duplicated name", func() { - sec, err := f.NewRawSection("comments", `1111111111111111111000000000000000001110000`) - So(err, ShouldBeNil) - So(sec, ShouldNotBeNil) - So(f.SectionStrings(), ShouldResemble, []string{ini.DefaultSection, "comments"}) - - // Overwrite previous existed section - So(f.Section("comments").Body(), ShouldEqual, `1111111111111111111000000000000000001110000`) - }) + require.NoError(t, err) + require.NotNil(t, sec) + assert.Equal(t, "comments", sec.Name()) + + assert.Equal(t, []string{ini.DefaultSection, "comments"}, f.SectionStrings()) + assert.Equal(t, `1111111111111111111000000000000000001110000 +111111111111111111100000000000111000000000`, f.Section("comments").Body()) + + t.Run("with duplicated name", func(t *testing.T) { + sec, err := f.NewRawSection("comments", `1111111111111111111000000000000000001110000`) + require.NoError(t, err) + require.NotNil(t, sec) + assert.Equal(t, []string{ini.DefaultSection, "comments"}, f.SectionStrings()) + + // Overwrite previous existed section + assert.Equal(t, `1111111111111111111000000000000000001110000`, f.Section("comments").Body()) + }) - Convey("With empty string", func() { - _, err := f.NewRawSection("", "") - So(err, ShouldNotBeNil) - }) + t.Run("with empty string", func(t *testing.T) { + _, err := f.NewRawSection("", "") + require.Error(t, err) }) } func TestFile_NewSections(t *testing.T) { - Convey("Create new sections", t, func() { - f := ini.Empty() - So(f, ShouldNotBeNil) + f := ini.Empty() + require.NotNil(t, f) - So(f.NewSections("package", "author"), ShouldBeNil) - So(f.SectionStrings(), ShouldResemble, []string{ini.DefaultSection, "package", "author"}) + assert.NoError(t, f.NewSections("package", "author")) + assert.Equal(t, []string{ini.DefaultSection, "package", "author"}, f.SectionStrings()) - Convey("With duplicated name", func() { - So(f.NewSections("author", "features"), ShouldBeNil) + t.Run("with duplicated name", func(t *testing.T) { + assert.NoError(t, f.NewSections("author", "features")) - // Ignore section already exists - So(f.SectionStrings(), ShouldResemble, []string{ini.DefaultSection, "package", "author", "features"}) - }) + // Ignore section already exists + assert.Equal(t, []string{ini.DefaultSection, "package", "author", "features"}, f.SectionStrings()) + }) - Convey("With empty string", func() { - So(f.NewSections("", ""), ShouldNotBeNil) - }) + t.Run("with empty string", func(t *testing.T) { + assert.Error(t, f.NewSections("", "")) }) } func TestFile_GetSection(t *testing.T) { - Convey("Get a section", t, func() { - f, err := ini.Load(fullConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - sec, err := f.GetSection("author") - So(err, ShouldBeNil) - So(sec, ShouldNotBeNil) - So(sec.Name(), ShouldEqual, "author") - - Convey("Section not exists", func() { - _, err := f.GetSection("404") - So(err, ShouldNotBeNil) - }) + f, err := ini.Load(fullConf) + require.NoError(t, err) + require.NotNil(t, f) + + sec, err := f.GetSection("author") + require.NoError(t, err) + require.NotNil(t, sec) + assert.Equal(t, "author", sec.Name()) + + t.Run("section not exists", func(t *testing.T) { + _, err := f.GetSection("404") + require.Error(t, err) }) } func TestFile_Section(t *testing.T) { - Convey("Get a section", t, func() { + t.Run("get a section", func(t *testing.T) { f, err := ini.Load(fullConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) sec := f.Section("author") - So(sec, ShouldNotBeNil) - So(sec.Name(), ShouldEqual, "author") + require.NotNil(t, sec) + assert.Equal(t, "author", sec.Name()) - Convey("Section not exists", func() { + t.Run("section not exists", func(t *testing.T) { sec := f.Section("404") - So(sec, ShouldNotBeNil) - So(sec.Name(), ShouldEqual, "404") + require.NotNil(t, sec) + assert.Equal(t, "404", sec.Name()) }) }) - Convey("Get default section in lower case with insensitive load", t, func() { + t.Run("get default section in lower case with insensitive load", func(t *testing.T) { f, err := ini.InsensitiveLoad([]byte(` [default] NAME = ini VERSION = v1`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("name").String(), ShouldEqual, "ini") - So(f.Section("").Key("version").String(), ShouldEqual, "v1") + assert.Equal(t, "ini", f.Section("").Key("name").String()) + assert.Equal(t, "v1", f.Section("").Key("version").String()) }) } func TestFile_Sections(t *testing.T) { - Convey("Get all sections", t, func() { - f, err := ini.Load(fullConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - secs := f.Sections() - names := []string{ini.DefaultSection, "author", "package", "package.sub", "features", "types", "array", "note", "comments", "string escapes", "advance"} - So(len(secs), ShouldEqual, len(names)) - for i, name := range names { - So(secs[i].Name(), ShouldEqual, name) - } - }) + f, err := ini.Load(fullConf) + require.NoError(t, err) + require.NotNil(t, f) + + secs := f.Sections() + names := []string{ini.DefaultSection, "author", "package", "package.sub", "features", "types", "array", "note", "comments", "string escapes", "advance"} + assert.Len(t, secs, len(names)) + for i, name := range names { + assert.Equal(t, name, secs[i].Name()) + } } func TestFile_ChildSections(t *testing.T) { - Convey("Get child sections by parent name", t, func() { - f, err := ini.Load([]byte(` + f, err := ini.Load([]byte(` [node] [node.biz1] [node.biz2] [node.biz3] [node.bizN] `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - children := f.ChildSections("node") - names := []string{"node.biz1", "node.biz2", "node.biz3", "node.bizN"} - So(len(children), ShouldEqual, len(names)) - for i, name := range names { - So(children[i].Name(), ShouldEqual, name) - } - }) + require.NoError(t, err) + require.NotNil(t, f) + + children := f.ChildSections("node") + names := []string{"node.biz1", "node.biz2", "node.biz3", "node.bizN"} + assert.Len(t, children, len(names)) + for i, name := range names { + assert.Equal(t, name, children[i].Name()) + } } func TestFile_SectionStrings(t *testing.T) { - Convey("Get all section names", t, func() { - f, err := ini.Load(fullConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + f, err := ini.Load(fullConf) + require.NoError(t, err) + require.NotNil(t, f) - So(f.SectionStrings(), ShouldResemble, []string{ini.DefaultSection, "author", "package", "package.sub", "features", "types", "array", "note", "comments", "string escapes", "advance"}) - }) + assert.Equal(t, []string{ini.DefaultSection, "author", "package", "package.sub", "features", "types", "array", "note", "comments", "string escapes", "advance"}, f.SectionStrings()) } func TestFile_DeleteSection(t *testing.T) { - Convey("Delete a section", t, func() { + t.Run("delete a section", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) _ = f.NewSections("author", "package", "features") f.DeleteSection("features") f.DeleteSection("") - So(f.SectionStrings(), ShouldResemble, []string{"author", "package"}) + assert.Equal(t, []string{"author", "package"}, f.SectionStrings()) }) - Convey("Delete default section", t, func() { + t.Run("delete default section", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) f.Section("").Key("foo").SetValue("bar") f.Section("section1").Key("key1").SetValue("value1") f.DeleteSection("") - So(f.SectionStrings(), ShouldResemble, []string{"section1"}) + assert.Equal(t, []string{"section1"}, f.SectionStrings()) var buf bytes.Buffer _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) + require.NoError(t, err) - So(buf.String(), ShouldEqual, `[section1] + assert.Equal(t, `[section1] key1 = value1 -`) +`, buf.String()) }) - Convey("Delete a section with InsensitiveSections", t, func() { + t.Run("delete a section with InsensitiveSections", func(t *testing.T) { f := ini.Empty(ini.LoadOptions{InsensitiveSections: true}) - So(f, ShouldNotBeNil) + require.NotNil(t, f) _ = f.NewSections("author", "package", "features") f.DeleteSection("FEATURES") f.DeleteSection("") - So(f.SectionStrings(), ShouldResemble, []string{"author", "package"}) + assert.Equal(t, []string{"author", "package"}, f.SectionStrings()) }) } func TestFile_Append(t *testing.T) { - Convey("Append a data source", t, func() { - f := ini.Empty() - So(f, ShouldNotBeNil) + f := ini.Empty() + require.NotNil(t, f) - So(f.Append(minimalConf, []byte(` + assert.NoError(t, f.Append(minimalConf, []byte(` [author] -NAME = Unknwon`)), ShouldBeNil) +NAME = Unknwon`))) - Convey("With bad input", func() { - So(f.Append(123), ShouldNotBeNil) - So(f.Append(minimalConf, 123), ShouldNotBeNil) - }) + t.Run("with bad input", func(t *testing.T) { + assert.Error(t, f.Append(123)) + assert.Error(t, f.Append(minimalConf, 123)) }) } @@ -384,10 +368,10 @@ func TestFile_WriteTo(t *testing.T) { t.Skip("Skipping testing on Windows") } - Convey("Write content to somewhere", t, func() { + t.Run("write content to somewhere", func(t *testing.T) { f, err := ini.Load(fullConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) f.Section("author").Comment = `Information about package author # Bio can be written in multiple lines.` @@ -397,19 +381,19 @@ func TestFile_WriteTo(t *testing.T) { var buf bytes.Buffer _, err = f.WriteTo(&buf) - So(err, ShouldBeNil) + require.NoError(t, err) golden := "testdata/TestFile_WriteTo.golden" if *update { - So(ioutil.WriteFile(golden, buf.Bytes(), 0644), ShouldBeNil) + require.NoError(t, ioutil.WriteFile(golden, buf.Bytes(), 0644)) } expected, err := ioutil.ReadFile(golden) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, string(expected)) + require.NoError(t, err) + assert.Equal(t, string(expected), buf.String()) }) - Convey("Support multiline comments", t, func() { + t.Run("support multiline comments", func(t *testing.T) { f, err := ini.Load([]byte(` # # general.domain @@ -417,15 +401,15 @@ func TestFile_WriteTo(t *testing.T) { # Domain name of XX system. domain = mydomain.com `)) - So(err, ShouldBeNil) + require.NoError(t, err) f.Section("").Key("test").Comment = "Multiline\nComment" var buf bytes.Buffer _, err = f.WriteTo(&buf) - So(err, ShouldBeNil) + require.NoError(t, err) - So(buf.String(), ShouldEqual, `# + assert.Equal(t, `# # general.domain # # Domain name of XX system. @@ -434,46 +418,43 @@ domain = mydomain.com ; Comment test = -`) +`, buf.String()) }) - Convey("Keep leading and trailing spaces in value", t, func() { + t.Run("keep leading and trailing spaces in value", func(t *testing.T) { f, _ := ini.Load([]byte(`[foo] bar1 = ' val ue1 ' bar2 = """ val ue2 """ bar3 = " val ue3 " `)) - So(f, ShouldNotBeNil) + require.NotNil(t, f) var buf bytes.Buffer _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[foo] + require.NoError(t, err) + assert.Equal(t, `[foo] bar1 = " val ue1 " bar2 = " val ue2 " bar3 = " val ue3 " -`) +`, buf.String()) }) } func TestFile_SaveTo(t *testing.T) { - Convey("Write content to somewhere", t, func() { - f, err := ini.Load(fullConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + f, err := ini.Load(fullConf) + require.NoError(t, err) + require.NotNil(t, f) - So(f.SaveTo("testdata/conf_out.ini"), ShouldBeNil) - So(f.SaveToIndent("testdata/conf_out.ini", "\t"), ShouldBeNil) - }) + assert.NoError(t, f.SaveTo("testdata/conf_out.ini")) + assert.NoError(t, f.SaveToIndent("testdata/conf_out.ini", "\t")) } func TestFile_WriteToWithOutputDelimiter(t *testing.T) { - Convey("Write content to somewhere using a custom output delimiter", t, func() { - f, err := ini.LoadSources(ini.LoadOptions{ - KeyValueDelimiterOnWrite: "->", - }, []byte(`[Others] + f, err := ini.LoadSources(ini.LoadOptions{ + KeyValueDelimiterOnWrite: "->", + }, []byte(`[Others] Cities = HangZhou|Boston Visits = 1993-10-07T20:17:05Z, 1993-10-07T20:17:05Z Years = 1993,1994 @@ -483,11 +464,11 @@ Populations = 12345678,98765432 Coordinates = 192.168,10.11 Flags = true,false Note = Hello world!`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - var actual bytes.Buffer - var expected = []byte(`[Others] + var actual bytes.Buffer + var expected = []byte(`[Others] Cities -> HangZhou|Boston Visits -> 1993-10-07T20:17:05Z, 1993-10-07T20:17:05Z Years -> 1993,1994 @@ -499,28 +480,25 @@ Flags -> true,false Note -> Hello world! `) - _, err = f.WriteTo(&actual) - So(err, ShouldBeNil) + _, err = f.WriteTo(&actual) + require.NoError(t, err) - So(bytes.Equal(expected, actual.Bytes()), ShouldBeTrue) - }) + assert.Equal(t, expected, actual.Bytes()) } // Inspired by https://github.com/go-ini/ini/issues/207 func TestReloadAfterShadowLoad(t *testing.T) { - Convey("Reload file after ShadowLoad", t, func() { - f, err := ini.ShadowLoad([]byte(` + f, err := ini.ShadowLoad([]byte(` [slice] v = 1 v = 2 v = 3 `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("slice").Key("v").ValueWithShadows(), ShouldResemble, []string{"1", "2", "3"}) + assert.Equal(t, []string{"1", "2", "3"}, f.Section("slice").Key("v").ValueWithShadows()) - So(f.Reload(), ShouldBeNil) - So(f.Section("slice").Key("v").ValueWithShadows(), ShouldResemble, []string{"1", "2", "3"}) - }) + require.NoError(t, f.Reload()) + assert.Equal(t, []string{"1", "2", "3"}, f.Section("slice").Key("v").ValueWithShadows()) } diff --git a/helper_test.go b/helper_test.go index 1866479..439ad3b 100644 --- a/helper_test.go +++ b/helper_test.go @@ -17,13 +17,11 @@ package ini import ( "testing" - . "github.com/smartystreets/goconvey/convey" + "github.com/stretchr/testify/assert" ) -func Test_isSlice(t *testing.T) { - Convey("Check if a string is in the slice", t, func() { - ss := []string{"a", "b", "c"} - So(inSlice("a", ss), ShouldBeTrue) - So(inSlice("d", ss), ShouldBeFalse) - }) +func TestIsInSlice(t *testing.T) { + ss := []string{"a", "b", "c"} + assert.True(t, inSlice("a", ss)) + assert.False(t, inSlice("d", ss)) } diff --git a/ini_python_multiline_test.go b/ini_python_multiline_test.go index 9070c29..14fd7ec 100644 --- a/ini_python_multiline_test.go +++ b/ini_python_multiline_test.go @@ -5,7 +5,9 @@ import ( "runtime" "testing" - . "github.com/smartystreets/goconvey/convey" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "gopkg.in/ini.v1" ) @@ -20,25 +22,24 @@ func TestMultiline(t *testing.T) { t.Skip("Skipping testing on Windows") } - Convey("Parse Python-style multiline values", t, func() { - path := filepath.Join("testdata", "multiline.ini") - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: true, - ReaderBufferSize: 64 * 1024, - }, path) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - So(len(f.Sections()), ShouldEqual, 1) - - defaultSection := f.Section("") - So(f.Section(""), ShouldNotBeNil) - - var testData testData - err = defaultSection.MapTo(&testData) - So(err, ShouldBeNil) - So(testData.Value1, ShouldEqual, "some text here\nsome more text here\n\nthere is an empty line above and below\n") - So(testData.Value2, ShouldEqual, "there is an empty line above\nthat is not indented so it should not be part\nof the value") - So(testData.Value3, ShouldEqual, `. + path := filepath.Join("testdata", "multiline.ini") + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: true, + ReaderBufferSize: 64 * 1024, + }, path) + require.NoError(t, err) + require.NotNil(t, f) + assert.Len(t, f.Sections(), 1) + + defaultSection := f.Section("") + assert.NotNil(t, f.Section("")) + + var testData testData + err = defaultSection.MapTo(&testData) + require.NoError(t, err) + assert.Equal(t, "some text here\nsome more text here\n\nthere is an empty line above and below\n", testData.Value1) + assert.Equal(t, "there is an empty line above\nthat is not indented so it should not be part\nof the value", testData.Value2) + assert.Equal(t, `. Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Eu consequat ac felis donec et odio pellentesque diam volutpat. Mauris commodo quis imperdiet massa tincidunt nunc. Interdum velit euismod in pellentesque. Nisl condimentum id venenatis a condimentum vitae sapien pellentesque. Nascetur ridiculus mus mauris vitae. Posuere urna nec tincidunt praesent semper feugiat. Lorem donec massa sapien faucibus et molestie ac feugiat sed. Ipsum dolor sit amet consectetur adipiscing elit. Enim sed faucibus turpis in eu mi. A diam sollicitudin tempor id. Quam nulla porttitor massa id neque aliquam vestibulum morbi blandit. @@ -60,6 +61,7 @@ Malesuada fames ac turpis egestas. Suscipit tellus mauris a diam maecenas. Turpi Id ornare arcu odio ut sem. Arcu dictum varius duis at consectetur lorem donec massa sapien. Proin libero nunc consequat interdum varius sit. Ut eu sem integer vitae justo. Vitae elementum curabitur vitae nunc. Diam quam nulla porttitor massa. Lectus mauris ultrices eros in cursus turpis massa tincidunt dui. Natoque penatibus et magnis dis parturient montes. Pellentesque habitant morbi tristique senectus et netus et malesuada fames. Libero nunc consequat interdum varius sit. Rhoncus dolor purus non enim praesent. Pellentesque sit amet porttitor eget. Nibh tortor id aliquet lectus proin nibh. Fermentum iaculis eu non diam phasellus vestibulum lorem sed. -Eu feugiat pretium nibh ipsum consequat nisl vel pretium lectus. Habitant morbi tristique senectus et netus et malesuada fames ac. Urna condimentum mattis pellentesque id. Lorem sed risus ultricies tristique nulla aliquet enim tortor at. Ipsum dolor sit amet consectetur adipiscing elit. Convallis a cras semper auctor neque vitae tempus quam. A diam sollicitudin tempor id eu nisl nunc mi ipsum. Maecenas sed enim ut sem viverra aliquet eget. Massa enim nec dui nunc mattis enim. Nam aliquam sem et tortor consequat. Adipiscing commodo elit at imperdiet dui accumsan sit amet nulla. Nullam eget felis eget nunc lobortis. Mauris a diam maecenas sed enim ut sem viverra. Ornare massa eget egestas purus. In hac habitasse platea dictumst. Ut tortor pretium viverra suspendisse potenti nullam ac tortor. Nisl nunc mi ipsum faucibus. At varius vel pharetra vel. Mauris ultrices eros in cursus turpis massa tincidunt.`) - }) +Eu feugiat pretium nibh ipsum consequat nisl vel pretium lectus. Habitant morbi tristique senectus et netus et malesuada fames ac. Urna condimentum mattis pellentesque id. Lorem sed risus ultricies tristique nulla aliquet enim tortor at. Ipsum dolor sit amet consectetur adipiscing elit. Convallis a cras semper auctor neque vitae tempus quam. A diam sollicitudin tempor id eu nisl nunc mi ipsum. Maecenas sed enim ut sem viverra aliquet eget. Massa enim nec dui nunc mattis enim. Nam aliquam sem et tortor consequat. Adipiscing commodo elit at imperdiet dui accumsan sit amet nulla. Nullam eget felis eget nunc lobortis. Mauris a diam maecenas sed enim ut sem viverra. Ornare massa eget egestas purus. In hac habitasse platea dictumst. Ut tortor pretium viverra suspendisse potenti nullam ac tortor. Nisl nunc mi ipsum faucibus. At varius vel pharetra vel. Mauris ultrices eros in cursus turpis massa tincidunt.`, + testData.Value3, + ) } diff --git a/ini_test.go b/ini_test.go index fb9a681..aba6052 100644 --- a/ini_test.go +++ b/ini_test.go @@ -20,7 +20,9 @@ import ( "io/ioutil" "testing" - . "github.com/smartystreets/goconvey/convey" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "gopkg.in/ini.v1" ) @@ -51,56 +53,56 @@ const ( var update = flag.Bool("update", false, "Update .golden files") func TestLoad(t *testing.T) { - Convey("Load from good data sources", t, func() { + t.Run("load from good data sources", func(t *testing.T) { f, err := ini.Load( "testdata/minimal.ini", []byte("NAME = ini\nIMPORT_PATH = gopkg.in/%(NAME)s.%(VERSION)s"), bytes.NewReader([]byte(`VERSION = v1`)), ioutil.NopCloser(bytes.NewReader([]byte("[author]\nNAME = Unknwon"))), ) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) // Validate values make sure all sources are loaded correctly sec := f.Section("") - So(sec.Key("NAME").String(), ShouldEqual, "ini") - So(sec.Key("VERSION").String(), ShouldEqual, "v1") - So(sec.Key("IMPORT_PATH").String(), ShouldEqual, "gopkg.in/ini.v1") + assert.Equal(t, "ini", sec.Key("NAME").String()) + assert.Equal(t, "v1", sec.Key("VERSION").String()) + assert.Equal(t, "gopkg.in/ini.v1", sec.Key("IMPORT_PATH").String()) sec = f.Section("author") - So(sec.Key("NAME").String(), ShouldEqual, "Unknwon") - So(sec.Key("E-MAIL").String(), ShouldEqual, "u@gogs.io") + assert.Equal(t, "Unknwon", sec.Key("NAME").String()) + assert.Equal(t, "u@gogs.io", sec.Key("E-MAIL").String()) }) - Convey("Load from bad data sources", t, func() { - Convey("Invalid input", func() { + t.Run("load from bad data sources", func(t *testing.T) { + t.Run("invalid input", func(t *testing.T) { _, err := ini.Load(notFoundConf) - So(err, ShouldNotBeNil) + require.Error(t, err) }) - Convey("Unsupported type", func() { + t.Run("unsupported type", func(t *testing.T) { _, err := ini.Load(123) - So(err, ShouldNotBeNil) + require.Error(t, err) }) }) - Convey("Can't properly parse INI files containing `#` or `;` in value", t, func() { + t.Run("cannot properly parse INI files containing `#` or `;` in value", func(t *testing.T) { f, err := ini.Load([]byte(` [author] NAME = U#n#k#n#w#o#n GITHUB = U;n;k;n;w;o;n `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) sec := f.Section("author") nameValue := sec.Key("NAME").String() githubValue := sec.Key("GITHUB").String() - So(nameValue, ShouldEqual, "U") - So(githubValue, ShouldEqual, "U") + assert.Equal(t, "U", nameValue) + assert.Equal(t, "U", githubValue) }) - Convey("Can't parse small python-compatible INI files", t, func() { + t.Run("cannot parse small python-compatible INI files", func(t *testing.T) { f, err := ini.Load([]byte(` [long] long_rsa_private_key = -----BEGIN RSA PRIVATE KEY----- @@ -110,12 +112,12 @@ long_rsa_private_key = -----BEGIN RSA PRIVATE KEY----- barfoo -----END RSA PRIVATE KEY----- `)) - So(err, ShouldNotBeNil) - So(f, ShouldBeNil) - So(err.Error(), ShouldEqual, "key-value delimiter not found: foo\n") + require.Error(t, err) + assert.Nil(t, f) + assert.Equal(t, "key-value delimiter not found: foo\n", err.Error()) }) - Convey("Can't parse big python-compatible INI files", t, func() { + t.Run("cannot parse big python-compatible INI files", func(t *testing.T) { f, err := ini.Load([]byte(` [long] long_rsa_private_key = -----BEGIN RSA PRIVATE KEY----- @@ -217,217 +219,222 @@ long_rsa_private_key = -----BEGIN RSA PRIVATE KEY----- 96barfoo -----END RSA PRIVATE KEY----- `)) - So(err, ShouldNotBeNil) - So(f, ShouldBeNil) - So(err.Error(), ShouldEqual, "key-value delimiter not found: 1foo\n") + require.Error(t, err) + assert.Nil(t, f) + assert.Equal(t, "key-value delimiter not found: 1foo\n", err.Error()) }) } func TestLooseLoad(t *testing.T) { - Convey("Load from data sources with option `Loose` true", t, func() { - f, err := ini.LoadSources(ini.LoadOptions{Loose: true}, notFoundConf, minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - Convey("Inverse case", func() { - _, err = ini.Load(notFoundConf) - So(err, ShouldNotBeNil) - }) + f, err := ini.LoadSources(ini.LoadOptions{Loose: true}, notFoundConf, minimalConf) + require.NoError(t, err) + require.NotNil(t, f) + + t.Run("inverse case", func(t *testing.T) { + _, err = ini.Load(notFoundConf) + require.Error(t, err) }) } func TestInsensitiveLoad(t *testing.T) { - Convey("Insensitive to section and key names", t, func() { + t.Run("insensitive to section and key names", func(t *testing.T) { f, err := ini.InsensitiveLoad(minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("Author").Key("e-mail").String(), ShouldEqual, "u@gogs.io") + assert.Equal(t, "u@gogs.io", f.Section("Author").Key("e-mail").String()) - Convey("Write out", func() { + t.Run("write out", func(t *testing.T) { var buf bytes.Buffer _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[author] + require.NoError(t, err) + assert.Equal(t, `[author] e-mail = u@gogs.io -`) +`, + buf.String(), + ) }) - Convey("Inverse case", func() { + t.Run("inverse case", func(t *testing.T) { f, err := ini.Load(minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("Author").Key("e-mail").String(), ShouldBeEmpty) + assert.Empty(t, f.Section("Author").Key("e-mail").String()) }) }) // Ref: https://github.com/go-ini/ini/issues/198 - Convey("Insensitive load with default section", t, func() { + t.Run("insensitive load with default section", func(t *testing.T) { f, err := ini.InsensitiveLoad([]byte(` user = unknwon [profile] email = unknwon@local `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section(ini.DefaultSection).Key("user").String(), ShouldEqual, "unknwon") + assert.Equal(t, "unknwon", f.Section(ini.DefaultSection).Key("user").String()) }) } func TestLoadSources(t *testing.T) { - Convey("Load from data sources with options", t, func() { - Convey("with true `AllowPythonMultilineValues`", func() { - Convey("Ignore nonexistent files", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true, Loose: true}, notFoundConf, minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - Convey("Inverse case", func() { - _, err = ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, notFoundConf) - So(err, ShouldNotBeNil) - }) + t.Run("with true `AllowPythonMultilineValues`", func(t *testing.T) { + t.Run("ignore nonexistent files", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true, Loose: true}, notFoundConf, minimalConf) + require.NoError(t, err) + require.NotNil(t, f) + + t.Run("inverse case", func(t *testing.T) { + _, err = ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, notFoundConf) + require.Error(t, err) }) + }) - Convey("Insensitive to section and key names", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true, Insensitive: true}, minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + t.Run("insensitive to section and key names", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true, Insensitive: true}, minimalConf) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("Author").Key("e-mail").String(), ShouldEqual, "u@gogs.io") + assert.Equal(t, "u@gogs.io", f.Section("Author").Key("e-mail").String()) - Convey("Write out", func() { - var buf bytes.Buffer - _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[author] + t.Run("write out", func(t *testing.T) { + var buf bytes.Buffer + _, err := f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `[author] e-mail = u@gogs.io -`) - }) +`, + buf.String(), + ) + }) - Convey("Inverse case", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + t.Run("inverse case", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, minimalConf) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("Author").Key("e-mail").String(), ShouldBeEmpty) - }) + assert.Empty(t, f.Section("Author").Key("e-mail").String()) }) + }) - Convey("Insensitive to sections and sensitive to key names", func() { - f, err := ini.LoadSources(ini.LoadOptions{InsensitiveSections: true}, minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + t.Run("insensitive to sections and sensitive to key names", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{InsensitiveSections: true}, minimalConf) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("Author").Key("E-MAIL").String(), ShouldEqual, "u@gogs.io") + assert.Equal(t, "u@gogs.io", f.Section("Author").Key("E-MAIL").String()) - Convey("Write out", func() { - var buf bytes.Buffer - _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[author] + t.Run("write out", func(t *testing.T) { + var buf bytes.Buffer + _, err := f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `[author] E-MAIL = u@gogs.io -`) - }) +`, + buf.String(), + ) + }) - Convey("Inverse case", func() { - f, err := ini.LoadSources(ini.LoadOptions{}, minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + t.Run("inverse case", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{}, minimalConf) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("Author").Key("e-mail").String(), ShouldBeEmpty) - }) + assert.Empty(t, f.Section("Author").Key("e-mail").String()) }) + }) - Convey("Sensitive to sections and insensitive to key names", func() { - f, err := ini.LoadSources(ini.LoadOptions{InsensitiveKeys: true}, minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + t.Run("sensitive to sections and insensitive to key names", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{InsensitiveKeys: true}, minimalConf) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("author").Key("e-mail").String(), ShouldEqual, "u@gogs.io") + assert.Equal(t, "u@gogs.io", f.Section("author").Key("e-mail").String()) - Convey("Write out", func() { - var buf bytes.Buffer - _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[author] + t.Run("write out", func(t *testing.T) { + var buf bytes.Buffer + _, err := f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `[author] e-mail = u@gogs.io -`) - }) +`, + buf.String(), + ) + }) - Convey("Inverse case", func() { - f, err := ini.LoadSources(ini.LoadOptions{}, minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + t.Run("inverse case", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{}, minimalConf) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("Author").Key("e-mail").String(), ShouldBeEmpty) - }) + assert.Empty(t, f.Section("Author").Key("e-mail").String()) }) + }) - Convey("Ignore continuation lines", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: true, - IgnoreContinuation: true, - }, []byte(` + t.Run("ignore continuation lines", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: true, + IgnoreContinuation: true, + }, []byte(` key1=a\b\ key2=c\d\ key3=value`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("key1").String(), ShouldEqual, `a\b\`) - So(f.Section("").Key("key2").String(), ShouldEqual, `c\d\`) - So(f.Section("").Key("key3").String(), ShouldEqual, "value") + assert.Equal(t, `a\b\`, f.Section("").Key("key1").String()) + assert.Equal(t, `c\d\`, f.Section("").Key("key2").String()) + assert.Equal(t, "value", f.Section("").Key("key3").String()) - Convey("Inverse case", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, []byte(` + t.Run("inverse case", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, []byte(` key1=a\b\ key2=c\d\`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("key1").String(), ShouldEqual, `a\bkey2=c\d`) - }) + assert.Equal(t, `a\bkey2=c\d`, f.Section("").Key("key1").String()) }) + }) - Convey("Ignore inline comments", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: true, - IgnoreInlineComment: true, - }, []byte(` + t.Run("ignore inline comments", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: true, + IgnoreInlineComment: true, + }, []byte(` key1=value ;comment key2=value2 #comment2 key3=val#ue #comment3`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("key1").String(), ShouldEqual, `value ;comment`) - So(f.Section("").Key("key2").String(), ShouldEqual, `value2 #comment2`) - So(f.Section("").Key("key3").String(), ShouldEqual, `val#ue #comment3`) + assert.Equal(t, `value ;comment`, f.Section("").Key("key1").String()) + assert.Equal(t, `value2 #comment2`, f.Section("").Key("key2").String()) + assert.Equal(t, `val#ue #comment3`, f.Section("").Key("key3").String()) - Convey("Inverse case", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, []byte(` + t.Run("inverse case", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, []byte(` key1=value ;comment key2=value2 #comment2`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - So(f.Section("").Key("key1").String(), ShouldEqual, `value`) - So(f.Section("").Key("key1").Comment, ShouldEqual, `;comment`) - So(f.Section("").Key("key2").String(), ShouldEqual, `value2`) - So(f.Section("").Key("key2").Comment, ShouldEqual, `#comment2`) - }) + require.NoError(t, err) + require.NotNil(t, f) + + assert.Equal(t, `value`, f.Section("").Key("key1").String()) + assert.Equal(t, `;comment`, f.Section("").Key("key1").Comment) + assert.Equal(t, `value2`, f.Section("").Key("key2").String()) + assert.Equal(t, `#comment2`, f.Section("").Key("key2").Comment) }) + }) - Convey("Skip unrecognizable lines", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - SkipUnrecognizableLines: true, - }, []byte(` + t.Run("skip unrecognizable lines", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + SkipUnrecognizableLines: true, + }, []byte(` GenerationDepth: 13 BiomeRarityScale: 100 @@ -439,128 +446,136 @@ BiomeRarityScale: 100 BiomeGroup(NormalBiomes, 3, 99, RoofedForestEnchanted, ForestSakura, FloatingJungle BiomeGroup(IceBiomes, 4, 85, Ice Plains) `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("GenerationDepth").String(), ShouldEqual, "13") - So(f.Section("").Key("BiomeRarityScale").String(), ShouldEqual, "100") - So(f.Section("").HasKey("BiomeGroup"), ShouldBeFalse) - }) + assert.Equal(t, "13", f.Section("").Key("GenerationDepth").String()) + assert.Equal(t, "100", f.Section("").Key("BiomeRarityScale").String()) + assert.False(t, f.Section("").HasKey("BiomeGroup")) + }) - Convey("Allow boolean type keys", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: true, - AllowBooleanKeys: true, - }, []byte(` + t.Run("allow boolean type keys", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: true, + AllowBooleanKeys: true, + }, []byte(` key1=hello #key2 key3`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").KeyStrings(), ShouldResemble, []string{"key1", "key3"}) - So(f.Section("").Key("key3").MustBool(false), ShouldBeTrue) + assert.Equal(t, []string{"key1", "key3"}, f.Section("").KeyStrings()) + assert.True(t, f.Section("").Key("key3").MustBool(false)) - Convey("Write out", func() { - var buf bytes.Buffer - _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `key1 = hello + t.Run("write out", func(t *testing.T) { + var buf bytes.Buffer + _, err := f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `key1 = hello # key2 key3 -`) - }) +`, + buf.String(), + ) + }) - Convey("Inverse case", func() { - _, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, []byte(` + t.Run("inverse case", func(t *testing.T) { + _, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, []byte(` key1=hello #key2 key3`)) - So(err, ShouldNotBeNil) - }) + require.Error(t, err) }) + }) - Convey("Allow shadow keys", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowShadows: true, AllowPythonMultilineValues: true}, []byte(` + t.Run("allow shadow keys", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowShadows: true, AllowPythonMultilineValues: true}, []byte(` [remote "origin"] url = https://github.com/Antergone/test1.git url = https://github.com/Antergone/test2.git fetch = +refs/heads/*:refs/remotes/origin/*`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section(`remote "origin"`).Key("url").String(), ShouldEqual, "https://github.com/Antergone/test1.git") - So(f.Section(`remote "origin"`).Key("url").ValueWithShadows(), ShouldResemble, []string{ + assert.Equal(t, "https://github.com/Antergone/test1.git", f.Section(`remote "origin"`).Key("url").String()) + assert.Equal( + t, + []string{ "https://github.com/Antergone/test1.git", "https://github.com/Antergone/test2.git", - }) - So(f.Section(`remote "origin"`).Key("fetch").String(), ShouldEqual, "+refs/heads/*:refs/remotes/origin/*") - - Convey("Write out", func() { - var buf bytes.Buffer - _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[remote "origin"] + }, + f.Section(`remote "origin"`).Key("url").ValueWithShadows(), + ) + assert.Equal(t, "+refs/heads/*:refs/remotes/origin/*", f.Section(`remote "origin"`).Key("fetch").String()) + + t.Run("write out", func(t *testing.T) { + var buf bytes.Buffer + _, err := f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `[remote "origin"] url = https://github.com/Antergone/test1.git url = https://github.com/Antergone/test2.git fetch = +refs/heads/*:refs/remotes/origin/* -`) - }) +`, + buf.String(), + ) + }) - Convey("Inverse case", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, []byte(` + t.Run("inverse case", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, []byte(` [remote "origin"] url = https://github.com/Antergone/test1.git url = https://github.com/Antergone/test2.git`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section(`remote "origin"`).Key("url").String(), ShouldEqual, "https://github.com/Antergone/test2.git") - }) + assert.Equal(t, "https://github.com/Antergone/test2.git", f.Section(`remote "origin"`).Key("url").String()) }) + }) - Convey("Unescape double quotes inside value", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: true, - UnescapeValueDoubleQuotes: true, - }, []byte(` + t.Run("unescape double quotes inside value", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: true, + UnescapeValueDoubleQuotes: true, + }, []byte(` create_repo="创建了仓库 %s"`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("create_repo").String(), ShouldEqual, `创建了仓库 %s`) + assert.Equal(t, `创建了仓库 %s`, f.Section("").Key("create_repo").String()) - Convey("Inverse case", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, []byte(` + t.Run("inverse case", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, []byte(` create_repo="创建了仓库 %s"`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("create_repo").String(), ShouldEqual, `"创建了仓库 %s"`) - }) + assert.Equal(t, `"创建了仓库 %s"`, f.Section("").Key("create_repo").String()) }) + }) - Convey("Unescape comment symbols inside value", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: true, - IgnoreInlineComment: true, - UnescapeValueCommentSymbols: true, - }, []byte(` + t.Run("unescape comment symbols inside value", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: true, + IgnoreInlineComment: true, + UnescapeValueCommentSymbols: true, + }, []byte(` key = test value more text `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("key").String(), ShouldEqual, `test value more text`) - }) + assert.Equal(t, `test value more text`, f.Section("").Key("key").String()) + }) - Convey("Can parse small python-compatible INI files", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: true, - Insensitive: true, - UnparseableSections: []string{"core_lesson", "comments"}, - }, []byte(` + t.Run("can parse small python-compatible INI files", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: true, + Insensitive: true, + UnparseableSections: []string{"core_lesson", "comments"}, + }, []byte(` [long] long_rsa_private_key = -----BEGIN RSA PRIVATE KEY----- foo @@ -573,19 +588,19 @@ multiline_list = second third `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("long").Key("long_rsa_private_key").String(), ShouldEqual, "-----BEGIN RSA PRIVATE KEY-----\nfoo\nbar\nfoobar\nbarfoo\n-----END RSA PRIVATE KEY-----") - So(f.Section("long").Key("multiline_list").String(), ShouldEqual, "\nfirst\nsecond\nthird") - }) + assert.Equal(t, "-----BEGIN RSA PRIVATE KEY-----\nfoo\nbar\nfoobar\nbarfoo\n-----END RSA PRIVATE KEY-----", f.Section("long").Key("long_rsa_private_key").String()) + assert.Equal(t, "\nfirst\nsecond\nthird", f.Section("long").Key("multiline_list").String()) + }) - Convey("Can parse big python-compatible INI files", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: true, - Insensitive: true, - UnparseableSections: []string{"core_lesson", "comments"}, - }, []byte(` + t.Run("can parse big python-compatible INI files", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: true, + Insensitive: true, + UnparseableSections: []string{"core_lesson", "comments"}, + }, []byte(` [long] long_rsa_private_key = -----BEGIN RSA PRIVATE KEY----- 1foo @@ -686,10 +701,10 @@ long_rsa_private_key = -----BEGIN RSA PRIVATE KEY----- 96barfoo -----END RSA PRIVATE KEY----- `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("long").Key("long_rsa_private_key").String(), ShouldEqual, `-----BEGIN RSA PRIVATE KEY----- + assert.Equal(t, `-----BEGIN RSA PRIVATE KEY----- 1foo 2bar 3foobar @@ -786,15 +801,17 @@ long_rsa_private_key = -----BEGIN RSA PRIVATE KEY----- 94bar 95foobar 96barfoo ------END RSA PRIVATE KEY-----`) - }) +-----END RSA PRIVATE KEY-----`, + f.Section("long").Key("long_rsa_private_key").String(), + ) + }) - Convey("Allow unparsable sections", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: true, - Insensitive: true, - UnparseableSections: []string{"core_lesson", "comments"}, - }, []byte(` + t.Run("allow unparsable sections", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: true, + Insensitive: true, + UnparseableSections: []string{"core_lesson", "comments"}, + }, []byte(` Lesson_Location = 87 Lesson_Status = C Score = 3 @@ -806,20 +823,22 @@ my lesson state data – 1111111111111111111000000000000000001110000 [COMMENTS] <1> This slide has the fuel listed in the wrong units `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - So(f.Section("").Key("score").String(), ShouldEqual, "3") - So(f.Section("").Body(), ShouldBeEmpty) - So(f.Section("core_lesson").Body(), ShouldEqual, `my lesson state data – 1111111111111111111000000000000000001110000 -111111111111111111100000000000111000000000 – end my lesson state data`) - So(f.Section("comments").Body(), ShouldEqual, `<1> This slide has the fuel listed in the wrong units `) - - Convey("Write out", func() { - var buf bytes.Buffer - _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `lesson_location = 87 + require.NoError(t, err) + require.NotNil(t, f) + + assert.Equal(t, "3", f.Section("").Key("score").String()) + assert.Empty(t, f.Section("").Body()) + assert.Equal(t, `my lesson state data – 1111111111111111111000000000000000001110000 +111111111111111111100000000000111000000000 – end my lesson state data`, + f.Section("core_lesson").Body(), + ) + assert.Equal(t, `<1> This slide has the fuel listed in the wrong units `, f.Section("comments").Body()) + + t.Run("write out", func(t *testing.T) { + var buf bytes.Buffer + _, err := f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `lesson_location = 87 lesson_status = C score = 3 time = 00:02:30 @@ -830,270 +849,282 @@ my lesson state data – 1111111111111111111000000000000000001110000 [comments] <1> This slide has the fuel listed in the wrong units -`) - }) +`, + buf.String(), + ) + }) - Convey("Inverse case", func() { - _, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, []byte(` + t.Run("inverse case", func(t *testing.T) { + _, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: true}, []byte(` [CORE_LESSON] my lesson state data – 1111111111111111111000000000000000001110000 111111111111111111100000000000111000000000 – end my lesson state data`)) - So(err, ShouldNotBeNil) - }) + require.Error(t, err) }) + }) - Convey("And false `SpaceBeforeInlineComment`", func() { - Convey("Can't parse INI files containing `#` or `;` in value", func() { - f, err := ini.LoadSources( - ini.LoadOptions{AllowPythonMultilineValues: false, SpaceBeforeInlineComment: false}, - []byte(` + t.Run("and false `SpaceBeforeInlineComment`", func(t *testing.T) { + t.Run("cannot parse INI files containing `#` or `;` in value", func(t *testing.T) { + f, err := ini.LoadSources( + ini.LoadOptions{AllowPythonMultilineValues: false, SpaceBeforeInlineComment: false}, + []byte(` [author] NAME = U#n#k#n#w#o#n GITHUB = U;n;k;n;w;o;n `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - sec := f.Section("author") - nameValue := sec.Key("NAME").String() - githubValue := sec.Key("GITHUB").String() - So(nameValue, ShouldEqual, "U") - So(githubValue, ShouldEqual, "U") - }) + require.NoError(t, err) + require.NotNil(t, f) + sec := f.Section("author") + nameValue := sec.Key("NAME").String() + githubValue := sec.Key("GITHUB").String() + assert.Equal(t, "U", nameValue) + assert.Equal(t, "U", githubValue) }) + }) - Convey("And true `SpaceBeforeInlineComment`", func() { - Convey("Can parse INI files containing `#` or `;` in value", func() { - f, err := ini.LoadSources( - ini.LoadOptions{AllowPythonMultilineValues: false, SpaceBeforeInlineComment: true}, - []byte(` + t.Run("and true `SpaceBeforeInlineComment`", func(t *testing.T) { + t.Run("can parse INI files containing `#` or `;` in value", func(t *testing.T) { + f, err := ini.LoadSources( + ini.LoadOptions{AllowPythonMultilineValues: false, SpaceBeforeInlineComment: true}, + []byte(` [author] NAME = U#n#k#n#w#o#n GITHUB = U;n;k;n;w;o;n `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - sec := f.Section("author") - nameValue := sec.Key("NAME").String() - githubValue := sec.Key("GITHUB").String() - So(nameValue, ShouldEqual, "U#n#k#n#w#o#n") - So(githubValue, ShouldEqual, "U;n;k;n;w;o;n") - }) + require.NoError(t, err) + require.NotNil(t, f) + sec := f.Section("author") + nameValue := sec.Key("NAME").String() + githubValue := sec.Key("GITHUB").String() + assert.Equal(t, "U#n#k#n#w#o#n", nameValue) + assert.Equal(t, "U;n;k;n;w;o;n", githubValue) }) }) + }) - Convey("with false `AllowPythonMultilineValues`", func() { - Convey("Ignore nonexistent files", func() { - f, err := ini.LoadSources(ini.LoadOptions{ + t.Run("with false `AllowPythonMultilineValues`", func(t *testing.T) { + t.Run("ignore nonexistent files", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: false, + Loose: true, + }, notFoundConf, minimalConf) + require.NoError(t, err) + require.NotNil(t, f) + + t.Run("inverse case", func(t *testing.T) { + _, err = ini.LoadSources(ini.LoadOptions{ AllowPythonMultilineValues: false, - Loose: true, - }, notFoundConf, minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - Convey("Inverse case", func() { - _, err = ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: false, - }, notFoundConf) - So(err, ShouldNotBeNil) - }) + }, notFoundConf) + require.Error(t, err) }) + }) - Convey("Insensitive to section and key names", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: false, - Insensitive: true, - }, minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + t.Run("insensitive to section and key names", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: false, + Insensitive: true, + }, minimalConf) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("Author").Key("e-mail").String(), ShouldEqual, "u@gogs.io") + assert.Equal(t, "u@gogs.io", f.Section("Author").Key("e-mail").String()) - Convey("Write out", func() { - var buf bytes.Buffer - _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[author] + t.Run("write out", func(t *testing.T) { + var buf bytes.Buffer + _, err := f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `[author] e-mail = u@gogs.io -`) - }) - - Convey("Inverse case", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: false, - }, minimalConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - So(f.Section("Author").Key("e-mail").String(), ShouldBeEmpty) - }) +`, + buf.String(), + ) }) - Convey("Ignore continuation lines", func() { + t.Run("inverse case", func(t *testing.T) { f, err := ini.LoadSources(ini.LoadOptions{ AllowPythonMultilineValues: false, - IgnoreContinuation: true, - }, []byte(` + }, minimalConf) + require.NoError(t, err) + require.NotNil(t, f) + + assert.Empty(t, f.Section("Author").Key("e-mail").String()) + }) + }) + + t.Run("ignore continuation lines", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: false, + IgnoreContinuation: true, + }, []byte(` key1=a\b\ key2=c\d\ key3=value`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("key1").String(), ShouldEqual, `a\b\`) - So(f.Section("").Key("key2").String(), ShouldEqual, `c\d\`) - So(f.Section("").Key("key3").String(), ShouldEqual, "value") + assert.Equal(t, `a\b\`, f.Section("").Key("key1").String()) + assert.Equal(t, `c\d\`, f.Section("").Key("key2").String()) + assert.Equal(t, "value", f.Section("").Key("key3").String()) - Convey("Inverse case", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` + t.Run("inverse case", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` key1=a\b\ key2=c\d\`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("key1").String(), ShouldEqual, `a\bkey2=c\d`) - }) + assert.Equal(t, `a\bkey2=c\d`, f.Section("").Key("key1").String()) }) + }) - Convey("Ignore inline comments", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: false, - IgnoreInlineComment: true, - }, []byte(` + t.Run("ignore inline comments", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: false, + IgnoreInlineComment: true, + }, []byte(` key1=value ;comment key2=value2 #comment2 key3=val#ue #comment3`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("key1").String(), ShouldEqual, `value ;comment`) - So(f.Section("").Key("key2").String(), ShouldEqual, `value2 #comment2`) - So(f.Section("").Key("key3").String(), ShouldEqual, `val#ue #comment3`) + assert.Equal(t, `value ;comment`, f.Section("").Key("key1").String()) + assert.Equal(t, `value2 #comment2`, f.Section("").Key("key2").String()) + assert.Equal(t, `val#ue #comment3`, f.Section("").Key("key3").String()) - Convey("Inverse case", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` + t.Run("inverse case", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` key1=value ;comment key2=value2 #comment2`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - So(f.Section("").Key("key1").String(), ShouldEqual, `value`) - So(f.Section("").Key("key1").Comment, ShouldEqual, `;comment`) - So(f.Section("").Key("key2").String(), ShouldEqual, `value2`) - So(f.Section("").Key("key2").Comment, ShouldEqual, `#comment2`) - }) + require.NoError(t, err) + require.NotNil(t, f) + + assert.Equal(t, `value`, f.Section("").Key("key1").String()) + assert.Equal(t, `;comment`, f.Section("").Key("key1").Comment) + assert.Equal(t, `value2`, f.Section("").Key("key2").String()) + assert.Equal(t, `#comment2`, f.Section("").Key("key2").Comment) }) + }) - Convey("Allow boolean type keys", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: false, - AllowBooleanKeys: true, - }, []byte(` + t.Run("allow boolean type keys", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: false, + AllowBooleanKeys: true, + }, []byte(` key1=hello #key2 key3`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").KeyStrings(), ShouldResemble, []string{"key1", "key3"}) - So(f.Section("").Key("key3").MustBool(false), ShouldBeTrue) + assert.Equal(t, []string{"key1", "key3"}, f.Section("").KeyStrings()) + assert.True(t, f.Section("").Key("key3").MustBool(false)) - Convey("Write out", func() { - var buf bytes.Buffer - _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `key1 = hello + t.Run("write out", func(t *testing.T) { + var buf bytes.Buffer + _, err := f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `key1 = hello # key2 key3 -`) - }) +`, + buf.String(), + ) + }) - Convey("Inverse case", func() { - _, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` + t.Run("inverse case", func(t *testing.T) { + _, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` key1=hello #key2 key3`)) - So(err, ShouldNotBeNil) - }) + require.Error(t, err) }) + }) - Convey("Allow shadow keys", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false, AllowShadows: true}, []byte(` + t.Run("allow shadow keys", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false, AllowShadows: true}, []byte(` [remote "origin"] url = https://github.com/Antergone/test1.git url = https://github.com/Antergone/test2.git fetch = +refs/heads/*:refs/remotes/origin/*`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section(`remote "origin"`).Key("url").String(), ShouldEqual, "https://github.com/Antergone/test1.git") - So(f.Section(`remote "origin"`).Key("url").ValueWithShadows(), ShouldResemble, []string{ + assert.Equal(t, "https://github.com/Antergone/test1.git", f.Section(`remote "origin"`).Key("url").String()) + assert.Equal( + t, + []string{ "https://github.com/Antergone/test1.git", "https://github.com/Antergone/test2.git", - }) - So(f.Section(`remote "origin"`).Key("fetch").String(), ShouldEqual, "+refs/heads/*:refs/remotes/origin/*") - - Convey("Write out", func() { - var buf bytes.Buffer - _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[remote "origin"] + }, + f.Section(`remote "origin"`).Key("url").ValueWithShadows(), + ) + assert.Equal(t, "+refs/heads/*:refs/remotes/origin/*", f.Section(`remote "origin"`).Key("fetch").String()) + + t.Run("write out", func(t *testing.T) { + var buf bytes.Buffer + _, err := f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `[remote "origin"] url = https://github.com/Antergone/test1.git url = https://github.com/Antergone/test2.git fetch = +refs/heads/*:refs/remotes/origin/* -`) - }) +`, + buf.String(), + ) + }) - Convey("Inverse case", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` + t.Run("inverse case", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` [remote "origin"] url = https://github.com/Antergone/test1.git url = https://github.com/Antergone/test2.git`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section(`remote "origin"`).Key("url").String(), ShouldEqual, "https://github.com/Antergone/test2.git") - }) + assert.Equal(t, "https://github.com/Antergone/test2.git", f.Section(`remote "origin"`).Key("url").String()) }) + }) - Convey("Unescape double quotes inside value", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: false, - UnescapeValueDoubleQuotes: true, - }, []byte(` + t.Run("unescape double quotes inside value", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: false, + UnescapeValueDoubleQuotes: true, + }, []byte(` create_repo="创建了仓库 %s"`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("create_repo").String(), ShouldEqual, `创建了仓库 %s`) + assert.Equal(t, `创建了仓库 %s`, f.Section("").Key("create_repo").String()) - Convey("Inverse case", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` + t.Run("inverse case", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` create_repo="创建了仓库 %s"`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("create_repo").String(), ShouldEqual, `"创建了仓库 %s"`) - }) + assert.Equal(t, `"创建了仓库 %s"`, f.Section("").Key("create_repo").String()) }) + }) - Convey("Unescape comment symbols inside value", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: false, - IgnoreInlineComment: true, - UnescapeValueCommentSymbols: true, - }, []byte(` + t.Run("unescape comment symbols inside value", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: false, + IgnoreInlineComment: true, + UnescapeValueCommentSymbols: true, + }, []byte(` key = test value more text `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("key").String(), ShouldEqual, `test value more text`) - }) + assert.Equal(t, `test value more text`, f.Section("").Key("key").String()) + }) - Convey("Can't parse small python-compatible INI files", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` + t.Run("cannot parse small python-compatible INI files", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` [long] long_rsa_private_key = -----BEGIN RSA PRIVATE KEY----- foo @@ -1102,13 +1133,13 @@ long_rsa_private_key = -----BEGIN RSA PRIVATE KEY----- barfoo -----END RSA PRIVATE KEY----- `)) - So(err, ShouldNotBeNil) - So(f, ShouldBeNil) - So(err.Error(), ShouldEqual, "key-value delimiter not found: foo\n") - }) + require.Error(t, err) + assert.Nil(t, f) + assert.Equal(t, "key-value delimiter not found: foo\n", err.Error()) + }) - Convey("Can't parse big python-compatible INI files", func() { - f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` + t.Run("cannot parse big python-compatible INI files", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` [long] long_rsa_private_key = -----BEGIN RSA PRIVATE KEY----- 1foo @@ -1209,17 +1240,17 @@ long_rsa_private_key = -----BEGIN RSA PRIVATE KEY----- 96barfoo -----END RSA PRIVATE KEY----- `)) - So(err, ShouldNotBeNil) - So(f, ShouldBeNil) - So(err.Error(), ShouldEqual, "key-value delimiter not found: 1foo\n") - }) + require.Error(t, err) + assert.Nil(t, f) + assert.Equal(t, "key-value delimiter not found: 1foo\n", err.Error()) + }) - Convey("Allow unparsable sections", func() { - f, err := ini.LoadSources(ini.LoadOptions{ - AllowPythonMultilineValues: false, - Insensitive: true, - UnparseableSections: []string{"core_lesson", "comments"}, - }, []byte(` + t.Run("allow unparsable sections", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ + AllowPythonMultilineValues: false, + Insensitive: true, + UnparseableSections: []string{"core_lesson", "comments"}, + }, []byte(` Lesson_Location = 87 Lesson_Status = C Score = 3 @@ -1231,20 +1262,22 @@ my lesson state data – 1111111111111111111000000000000000001110000 [COMMENTS] <1> This slide has the fuel listed in the wrong units `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - So(f.Section("").Key("score").String(), ShouldEqual, "3") - So(f.Section("").Body(), ShouldBeEmpty) - So(f.Section("core_lesson").Body(), ShouldEqual, `my lesson state data – 1111111111111111111000000000000000001110000 -111111111111111111100000000000111000000000 – end my lesson state data`) - So(f.Section("comments").Body(), ShouldEqual, `<1> This slide has the fuel listed in the wrong units `) - - Convey("Write out", func() { - var buf bytes.Buffer - _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `lesson_location = 87 + require.NoError(t, err) + require.NotNil(t, f) + + assert.Equal(t, "3", f.Section("").Key("score").String()) + assert.Empty(t, f.Section("").Body()) + assert.Equal(t, `my lesson state data – 1111111111111111111000000000000000001110000 +111111111111111111100000000000111000000000 – end my lesson state data`, + f.Section("core_lesson").Body(), + ) + assert.Equal(t, `<1> This slide has the fuel listed in the wrong units `, f.Section("comments").Body()) + + t.Run("write out", func(t *testing.T) { + var buf bytes.Buffer + _, err := f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `lesson_location = 87 lesson_status = C score = 3 time = 00:02:30 @@ -1255,172 +1288,179 @@ my lesson state data – 1111111111111111111000000000000000001110000 [comments] <1> This slide has the fuel listed in the wrong units -`) - }) +`, + buf.String(), + ) + }) - Convey("Inverse case", func() { - _, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` + t.Run("inverse case", func(t *testing.T) { + _, err := ini.LoadSources(ini.LoadOptions{AllowPythonMultilineValues: false}, []byte(` [CORE_LESSON] my lesson state data – 1111111111111111111000000000000000001110000 111111111111111111100000000000111000000000 – end my lesson state data`)) - So(err, ShouldNotBeNil) - }) + require.Error(t, err) }) + }) - Convey("And false `SpaceBeforeInlineComment`", func() { - Convey("Can't parse INI files containing `#` or `;` in value", func() { - f, err := ini.LoadSources( - ini.LoadOptions{AllowPythonMultilineValues: true, SpaceBeforeInlineComment: false}, - []byte(` + t.Run("and false `SpaceBeforeInlineComment`", func(t *testing.T) { + t.Run("cannot parse INI files containing `#` or `;` in value", func(t *testing.T) { + f, err := ini.LoadSources( + ini.LoadOptions{AllowPythonMultilineValues: true, SpaceBeforeInlineComment: false}, + []byte(` [author] NAME = U#n#k#n#w#o#n GITHUB = U;n;k;n;w;o;n `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - sec := f.Section("author") - nameValue := sec.Key("NAME").String() - githubValue := sec.Key("GITHUB").String() - So(nameValue, ShouldEqual, "U") - So(githubValue, ShouldEqual, "U") - }) + require.NoError(t, err) + require.NotNil(t, f) + sec := f.Section("author") + nameValue := sec.Key("NAME").String() + githubValue := sec.Key("GITHUB").String() + assert.Equal(t, "U", nameValue) + assert.Equal(t, "U", githubValue) }) + }) - Convey("And true `SpaceBeforeInlineComment`", func() { - Convey("Can parse INI files containing `#` or `;` in value", func() { - f, err := ini.LoadSources( - ini.LoadOptions{AllowPythonMultilineValues: true, SpaceBeforeInlineComment: true}, - []byte(` + t.Run("and true `SpaceBeforeInlineComment`", func(t *testing.T) { + t.Run("can parse INI files containing `#` or `;` in value", func(t *testing.T) { + f, err := ini.LoadSources( + ini.LoadOptions{AllowPythonMultilineValues: true, SpaceBeforeInlineComment: true}, + []byte(` [author] NAME = U#n#k#n#w#o#n GITHUB = U;n;k;n;w;o;n `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - sec := f.Section("author") - nameValue := sec.Key("NAME").String() - githubValue := sec.Key("GITHUB").String() - So(nameValue, ShouldEqual, "U#n#k#n#w#o#n") - So(githubValue, ShouldEqual, "U;n;k;n;w;o;n") - }) + require.NoError(t, err) + require.NotNil(t, f) + sec := f.Section("author") + nameValue := sec.Key("NAME").String() + githubValue := sec.Key("GITHUB").String() + assert.Equal(t, "U#n#k#n#w#o#n", nameValue) + assert.Equal(t, "U;n;k;n;w;o;n", githubValue) }) }) + }) + + t.Run("with `ChildSectionDelimiter` ':'", func(t *testing.T) { + t.Run("get all keys of parent sections", func(t *testing.T) { + f := ini.Empty(ini.LoadOptions{ChildSectionDelimiter: ":"}) + require.NotNil(t, f) + + k, err := f.Section("package").NewKey("NAME", "ini") + require.NoError(t, err) + assert.NotNil(t, k) + k, err = f.Section("package").NewKey("VERSION", "v1") + require.NoError(t, err) + assert.NotNil(t, k) + k, err = f.Section("package").NewKey("IMPORT_PATH", "gopkg.in/ini.v1") + require.NoError(t, err) + assert.NotNil(t, k) + + keys := f.Section("package:sub:sub2").ParentKeys() + names := []string{"NAME", "VERSION", "IMPORT_PATH"} + assert.Equal(t, len(names), len(keys)) + for i, name := range names { + assert.Equal(t, name, keys[i].Name()) + } + }) + + t.Run("getting and setting values", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ChildSectionDelimiter: ":"}, fullConf) + require.NoError(t, err) + require.NotNil(t, f) - Convey("with `ChildSectionDelimiter` ':'", func() { - Convey("Get all keys of parent sections", func() { - f := ini.Empty(ini.LoadOptions{ChildSectionDelimiter: ":"}) - So(f, ShouldNotBeNil) - - k, err := f.Section("package").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) - k, err = f.Section("package").NewKey("VERSION", "v1") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) - k, err = f.Section("package").NewKey("IMPORT_PATH", "gopkg.in/ini.v1") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) - - keys := f.Section("package:sub:sub2").ParentKeys() - names := []string{"NAME", "VERSION", "IMPORT_PATH"} - So(len(keys), ShouldEqual, len(names)) - for i, name := range names { - So(keys[i].Name(), ShouldEqual, name) + t.Run("get parent-keys that are available to the child section", func(t *testing.T) { + parentKeys := f.Section("package:sub").ParentKeys() + assert.NotNil(t, parentKeys) + for _, k := range parentKeys { + assert.Equal(t, "CLONE_URL", k.Name()) } }) - Convey("Getting and setting values", func() { - f, err := ini.LoadSources(ini.LoadOptions{ChildSectionDelimiter: ":"}, fullConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - Convey("Get parent-keys that are available to the child section", func() { - parentKeys := f.Section("package:sub").ParentKeys() - So(parentKeys, ShouldNotBeNil) - for _, k := range parentKeys { - So(k.Name(), ShouldEqual, "CLONE_URL") - } - }) - - Convey("Get parent section value", func() { - So(f.Section("package:sub").Key("CLONE_URL").String(), ShouldEqual, "https://gopkg.in/ini.v1") - So(f.Section("package:fake:sub").Key("CLONE_URL").String(), ShouldEqual, "https://gopkg.in/ini.v1") - }) + t.Run("get parent section value", func(t *testing.T) { + assert.Equal(t, "https://gopkg.in/ini.v1", f.Section("package:sub").Key("CLONE_URL").String()) + assert.Equal(t, "https://gopkg.in/ini.v1", f.Section("package:fake:sub").Key("CLONE_URL").String()) }) + }) - Convey("Get child sections by parent name", func() { - f, err := ini.LoadSources(ini.LoadOptions{ChildSectionDelimiter: ":"}, []byte(` + t.Run("get child sections by parent name", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ChildSectionDelimiter: ":"}, []byte(` [node] [node:biz1] [node:biz2] [node.biz3] [node.bizN] `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) - - children := f.ChildSections("node") - names := []string{"node:biz1", "node:biz2"} - So(len(children), ShouldEqual, len(names)) - for i, name := range names { - So(children[i].Name(), ShouldEqual, name) - } - }) + require.NoError(t, err) + require.NotNil(t, f) + + children := f.ChildSections("node") + names := []string{"node:biz1", "node:biz2"} + assert.Equal(t, len(names), len(children)) + for i, name := range names { + assert.Equal(t, name, children[i].Name()) + } }) + }) - Convey("ShortCircuit", func() { - Convey("Load the first available configuration, ignore other configuration", func() { - f, err := ini.LoadSources(ini.LoadOptions{ShortCircuit: true}, minimalConf, []byte(`key1 = value1`)) - So(f, ShouldNotBeNil) - So(err, ShouldBeNil) - var buf bytes.Buffer - _, err = f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[author] + t.Run("ShortCircuit", func(t *testing.T) { + t.Run("load the first available configuration, ignore other configuration", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ShortCircuit: true}, minimalConf, []byte(`key1 = value1`)) + require.NotNil(t, f) + require.NoError(t, err) + var buf bytes.Buffer + _, err = f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `[author] E-MAIL = u@gogs.io -`) - }) +`, + buf.String(), + ) + }) - Convey("Return an error when fail to load", func() { - f, err := ini.LoadSources(ini.LoadOptions{ShortCircuit: true}, notFoundConf, minimalConf) - So(f, ShouldBeNil) - So(err, ShouldNotBeNil) - }) + t.Run("return an error when fail to load", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ShortCircuit: true}, notFoundConf, minimalConf) + assert.Nil(t, f) + require.Error(t, err) + }) - Convey("Used with Loose to ignore errors that the file does not exist", func() { - f, err := ini.LoadSources(ini.LoadOptions{ShortCircuit: true, Loose: true}, notFoundConf, minimalConf) - So(f, ShouldNotBeNil) - So(err, ShouldBeNil) - var buf bytes.Buffer - _, err = f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[author] + t.Run("used with Loose to ignore errors that the file does not exist", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ShortCircuit: true, Loose: true}, notFoundConf, minimalConf) + require.NotNil(t, f) + require.NoError(t, err) + var buf bytes.Buffer + _, err = f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `[author] E-MAIL = u@gogs.io -`) - }) +`, + buf.String(), + ) + }) - Convey("Ensure all sources are loaded without ShortCircuit", func() { - f, err := ini.LoadSources(ini.LoadOptions{ShortCircuit: false}, minimalConf, []byte(`key1 = value1`)) - So(f, ShouldNotBeNil) - So(err, ShouldBeNil) - var buf bytes.Buffer - _, err = f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `key1 = value1 + t.Run("ensure all sources are loaded without ShortCircuit", func(t *testing.T) { + f, err := ini.LoadSources(ini.LoadOptions{ShortCircuit: false}, minimalConf, []byte(`key1 = value1`)) + require.NotNil(t, f) + require.NoError(t, err) + var buf bytes.Buffer + _, err = f.WriteTo(&buf) + require.NoError(t, err) + assert.Equal(t, `key1 = value1 [author] E-MAIL = u@gogs.io -`) - }) +`, + buf.String(), + ) }) }) } func Test_KeyValueDelimiters(t *testing.T) { - Convey("Custom key-value delimiters", t, func() { + t.Run("custom key-value delimiters", func(t *testing.T) { f, err := ini.LoadSources(ini.LoadOptions{ KeyValueDelimiters: "?!", }, []byte(` @@ -1428,16 +1468,16 @@ func Test_KeyValueDelimiters(t *testing.T) { key1?value1 key2!value2 `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("section").Key("key1").String(), ShouldEqual, "value1") - So(f.Section("section").Key("key2").String(), ShouldEqual, "value2") + assert.Equal(t, "value1", f.Section("section").Key("key1").String()) + assert.Equal(t, "value2", f.Section("section").Key("key2").String()) }) } func Test_PreserveSurroundedQuote(t *testing.T) { - Convey("Preserve surrounded quote test", t, func() { + t.Run("preserve surrounded quote test", func(t *testing.T) { f, err := ini.LoadSources(ini.LoadOptions{ PreserveSurroundedQuote: true, }, []byte(` @@ -1445,14 +1485,14 @@ func Test_PreserveSurroundedQuote(t *testing.T) { key1 = "value1" key2 = value2 `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("section").Key("key1").String(), ShouldEqual, "\"value1\"") - So(f.Section("section").Key("key2").String(), ShouldEqual, "value2") + assert.Equal(t, "\"value1\"", f.Section("section").Key("key1").String()) + assert.Equal(t, "value2", f.Section("section").Key("key2").String()) }) - Convey("Preserve surrounded quote test inverse test", t, func() { + t.Run("preserve surrounded quote test inverse test", func(t *testing.T) { f, err := ini.LoadSources(ini.LoadOptions{ PreserveSurroundedQuote: false, }, []byte(` @@ -1460,10 +1500,10 @@ key2 = value2 key1 = "value1" key2 = value2 `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("section").Key("key1").String(), ShouldEqual, "value1") - So(f.Section("section").Key("key2").String(), ShouldEqual, "value2") + assert.Equal(t, "value1", f.Section("section").Key("key1").String()) + assert.Equal(t, "value2", f.Section("section").Key("key2").String()) }) } diff --git a/key_test.go b/key_test.go index 3d4c0e3..913d802 100644 --- a/key_test.go +++ b/key_test.go @@ -22,525 +22,541 @@ import ( "testing" "time" - . "github.com/smartystreets/goconvey/convey" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "gopkg.in/ini.v1" ) func TestKey_AddShadow(t *testing.T) { - Convey("Add shadow to a key", t, func() { + t.Run("add shadow to a key", func(t *testing.T) { f, err := ini.ShadowLoad([]byte(` [notes] -: note1`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) - So(k.AddShadow("ini.v1"), ShouldBeNil) - So(k.ValueWithShadows(), ShouldResemble, []string{"ini", "ini.v1"}) + assert.NoError(t, k.AddShadow("ini.v1")) + assert.Equal(t, []string{"ini", "ini.v1"}, k.ValueWithShadows()) - Convey("Add shadow to boolean key", func() { + t.Run("add shadow to boolean key", func(t *testing.T) { k, err := f.Section("").NewBooleanKey("published") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) - So(k.AddShadow("beta"), ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) + assert.Error(t, k.AddShadow("beta")) }) - Convey("Add shadow to auto-increment key", func() { - So(f.Section("notes").Key("#1").AddShadow("beta"), ShouldNotBeNil) + t.Run("add shadow to auto-increment key", func(t *testing.T) { + assert.Error(t, f.Section("notes").Key("#1").AddShadow("beta")) }) - Convey("Deduplicate an existing value", func() { + t.Run("deduplicate an existing value", func(t *testing.T) { k := f.Section("").Key("NAME") - So(k.AddShadow("ini"), ShouldBeNil) - So(k.ValueWithShadows(), ShouldResemble, []string{"ini", "ini.v1"}) + assert.NoError(t, k.AddShadow("ini")) + assert.Equal(t, []string{"ini", "ini.v1"}, k.ValueWithShadows()) }) }) - Convey("Allow duplicate shadowed values", t, func() { + t.Run("allow duplicate shadowed values", func(t *testing.T) { f := ini.Empty(ini.LoadOptions{ AllowShadows: true, AllowDuplicateShadowValues: true, }) - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) - So(k.AddShadow("ini.v1"), ShouldBeNil) - So(k.AddShadow("ini"), ShouldBeNil) - So(k.AddShadow("ini"), ShouldBeNil) - So(k.ValueWithShadows(), ShouldResemble, []string{"ini", "ini.v1", "ini", "ini"}) + assert.NoError(t, k.AddShadow("ini.v1")) + assert.NoError(t, k.AddShadow("ini")) + assert.NoError(t, k.AddShadow("ini")) + assert.Equal(t, []string{"ini", "ini.v1", "ini", "ini"}, k.ValueWithShadows()) }) - Convey("Shadow is not allowed", t, func() { + t.Run("shadow is not allowed", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) - So(k.AddShadow("ini.v1"), ShouldNotBeNil) + assert.Error(t, k.AddShadow("ini.v1")) }) } // Helpers for slice tests. -func float64sEqual(values []float64, expected ...float64) { - So(values, ShouldHaveLength, len(expected)) +func float64sEqual(t *testing.T, values []float64, expected ...float64) { + t.Helper() + + assert.Len(t, values, len(expected)) for i, v := range expected { - So(values[i], ShouldEqual, v) + assert.Equal(t, v, values[i]) } } -func intsEqual(values []int, expected ...int) { - So(values, ShouldHaveLength, len(expected)) +func intsEqual(t *testing.T, values []int, expected ...int) { + t.Helper() + + assert.Len(t, values, len(expected)) for i, v := range expected { - So(values[i], ShouldEqual, v) + assert.Equal(t, v, values[i]) } } -func int64sEqual(values []int64, expected ...int64) { - So(values, ShouldHaveLength, len(expected)) +func int64sEqual(t *testing.T, values []int64, expected ...int64) { + t.Helper() + + assert.Len(t, values, len(expected)) for i, v := range expected { - So(values[i], ShouldEqual, v) + assert.Equal(t, v, values[i]) } } -func uintsEqual(values []uint, expected ...uint) { - So(values, ShouldHaveLength, len(expected)) +func uintsEqual(t *testing.T, values []uint, expected ...uint) { + t.Helper() + + assert.Len(t, values, len(expected)) for i, v := range expected { - So(values[i], ShouldEqual, v) + assert.Equal(t, v, values[i]) } } -func uint64sEqual(values []uint64, expected ...uint64) { - So(values, ShouldHaveLength, len(expected)) +func uint64sEqual(t *testing.T, values []uint64, expected ...uint64) { + t.Helper() + + assert.Len(t, values, len(expected)) for i, v := range expected { - So(values[i], ShouldEqual, v) + assert.Equal(t, v, values[i]) } } -func boolsEqual(values []bool, expected ...bool) { - So(values, ShouldHaveLength, len(expected)) +func boolsEqual(t *testing.T, values []bool, expected ...bool) { + t.Helper() + + assert.Len(t, values, len(expected)) for i, v := range expected { - So(values[i], ShouldEqual, v) + assert.Equal(t, v, values[i]) } } -func timesEqual(values []time.Time, expected ...time.Time) { - So(values, ShouldHaveLength, len(expected)) +func timesEqual(t *testing.T, values []time.Time, expected ...time.Time) { + t.Helper() + + assert.Len(t, values, len(expected)) for i, v := range expected { - So(values[i].String(), ShouldEqual, v.String()) + assert.Equal(t, v.String(), values[i].String()) } } func TestKey_Helpers(t *testing.T) { - Convey("Getting and setting values", t, func() { + t.Run("getting and setting values", func(t *testing.T) { f, err := ini.Load(fullConf) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - Convey("Get string representation", func() { + t.Run("get string representation", func(t *testing.T) { sec := f.Section("") - So(sec, ShouldNotBeNil) - So(sec.Key("NAME").Value(), ShouldEqual, "ini") - So(sec.Key("NAME").String(), ShouldEqual, "ini") - So(sec.Key("NAME").Validate(func(in string) string { + require.NotNil(t, sec) + assert.Equal(t, "ini", sec.Key("NAME").Value()) + assert.Equal(t, "ini", sec.Key("NAME").String()) + assert.Equal(t, "ini", sec.Key("NAME").Validate(func(in string) string { return in - }), ShouldEqual, "ini") - So(sec.Key("NAME").Comment, ShouldEqual, "; Package name") - So(sec.Key("IMPORT_PATH").String(), ShouldEqual, "gopkg.in/ini.v1") + })) + assert.Equal(t, "; Package name", sec.Key("NAME").Comment) + assert.Equal(t, "gopkg.in/ini.v1", sec.Key("IMPORT_PATH").String()) - Convey("With ValueMapper", func() { + t.Run("with ValueMapper", func(t *testing.T) { f.ValueMapper = func(in string) string { if in == "gopkg.in/%(NAME)s.%(VERSION)s" { return "github.com/go-ini/ini" } return in } - So(sec.Key("IMPORT_PATH").String(), ShouldEqual, "github.com/go-ini/ini") + assert.Equal(t, "github.com/go-ini/ini", sec.Key("IMPORT_PATH").String()) }) }) - Convey("Get values in non-default section", func() { + t.Run("get values in non-default section", func(t *testing.T) { sec := f.Section("author") - So(sec, ShouldNotBeNil) - So(sec.Key("NAME").String(), ShouldEqual, "Unknwon") - So(sec.Key("GITHUB").String(), ShouldEqual, "https://github.com/Unknwon") + require.NotNil(t, sec) + assert.Equal(t, "Unknwon", sec.Key("NAME").String()) + assert.Equal(t, "https://github.com/Unknwon", sec.Key("GITHUB").String()) sec = f.Section("package") - So(sec, ShouldNotBeNil) - So(sec.Key("CLONE_URL").String(), ShouldEqual, "https://gopkg.in/ini.v1") + require.NotNil(t, sec) + assert.Equal(t, "https://gopkg.in/ini.v1", sec.Key("CLONE_URL").String()) }) - Convey("Get auto-increment key names", func() { + t.Run("get auto-increment key names", func(t *testing.T) { keys := f.Section("features").Keys() for i, k := range keys { - So(k.Name(), ShouldEqual, fmt.Sprintf("#%d", i+1)) + assert.Equal(t, fmt.Sprintf("#%d", i+1), k.Name()) } }) - Convey("Get parent-keys that are available to the child section", func() { + t.Run("get parent-keys that are available to the child section", func(t *testing.T) { parentKeys := f.Section("package.sub").ParentKeys() for _, k := range parentKeys { - So(k.Name(), ShouldEqual, "CLONE_URL") + assert.Equal(t, "CLONE_URL", k.Name()) } }) - Convey("Get overwrite value", func() { - So(f.Section("author").Key("E-MAIL").String(), ShouldEqual, "u@gogs.io") + t.Run("get overwrite value", func(t *testing.T) { + assert.Equal(t, "u@gogs.io", f.Section("author").Key("E-MAIL").String()) }) - Convey("Get sections", func() { + t.Run("get sections", func(t *testing.T) { sections := f.Sections() for i, name := range []string{ini.DefaultSection, "author", "package", "package.sub", "features", "types", "array", "note", "comments", "string escapes", "advance"} { - So(sections[i].Name(), ShouldEqual, name) + assert.Equal(t, name, sections[i].Name()) } }) - Convey("Get parent section value", func() { - So(f.Section("package.sub").Key("CLONE_URL").String(), ShouldEqual, "https://gopkg.in/ini.v1") - So(f.Section("package.fake.sub").Key("CLONE_URL").String(), ShouldEqual, "https://gopkg.in/ini.v1") + t.Run("get parent section value", func(t *testing.T) { + assert.Equal(t, "https://gopkg.in/ini.v1", f.Section("package.sub").Key("CLONE_URL").String()) + assert.Equal(t, "https://gopkg.in/ini.v1", f.Section("package.fake.sub").Key("CLONE_URL").String()) }) - Convey("Get multiple line value", func() { + t.Run("get multiple line value", func(t *testing.T) { if runtime.GOOS == "windows" { t.Skip("Skipping testing on Windows") } - So(f.Section("author").Key("BIO").String(), ShouldEqual, "Gopher.\nCoding addict.\nGood man.\n") + assert.Equal(t, "Gopher.\nCoding addict.\nGood man.\n", f.Section("author").Key("BIO").String()) }) - Convey("Get values with type", func() { + t.Run("get values with type", func(t *testing.T) { sec := f.Section("types") v1, err := sec.Key("BOOL").Bool() - So(err, ShouldBeNil) - So(v1, ShouldBeTrue) + require.NoError(t, err) + assert.True(t, v1) v1, err = sec.Key("BOOL_FALSE").Bool() - So(err, ShouldBeNil) - So(v1, ShouldBeFalse) + require.NoError(t, err) + assert.False(t, v1) v2, err := sec.Key("FLOAT64").Float64() - So(err, ShouldBeNil) - So(v2, ShouldEqual, 1.25) + require.NoError(t, err) + assert.Equal(t, 1.25, v2) v3, err := sec.Key("INT").Int() - So(err, ShouldBeNil) - So(v3, ShouldEqual, 10) + require.NoError(t, err) + assert.Equal(t, 10, v3) v4, err := sec.Key("INT").Int64() - So(err, ShouldBeNil) - So(v4, ShouldEqual, 10) + require.NoError(t, err) + assert.Equal(t, int64(10), v4) v5, err := sec.Key("UINT").Uint() - So(err, ShouldBeNil) - So(v5, ShouldEqual, 3) + require.NoError(t, err) + assert.Equal(t, uint(3), v5) v6, err := sec.Key("UINT").Uint64() - So(err, ShouldBeNil) - So(v6, ShouldEqual, 3) + require.NoError(t, err) + assert.Equal(t, uint64(3), v6) - t, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z") - So(err, ShouldBeNil) + ti, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z") + require.NoError(t, err) v7, err := sec.Key("TIME").Time() - So(err, ShouldBeNil) - So(v7.String(), ShouldEqual, t.String()) + require.NoError(t, err) + assert.Equal(t, ti.String(), v7.String()) v8, err := sec.Key("HEX_NUMBER").Int() - So(err, ShouldBeNil) - So(v8, ShouldEqual, 0x3000) - - Convey("Must get values with type", func() { - So(sec.Key("STRING").MustString("404"), ShouldEqual, "str") - So(sec.Key("BOOL").MustBool(), ShouldBeTrue) - So(sec.Key("FLOAT64").MustFloat64(), ShouldEqual, 1.25) - So(sec.Key("INT").MustInt(), ShouldEqual, 10) - So(sec.Key("INT").MustInt64(), ShouldEqual, 10) - So(sec.Key("UINT").MustUint(), ShouldEqual, 3) - So(sec.Key("UINT").MustUint64(), ShouldEqual, 3) - So(sec.Key("TIME").MustTime().String(), ShouldEqual, t.String()) - So(sec.Key("HEX_NUMBER").MustInt(), ShouldEqual, 0x3000) + require.NoError(t, err) + assert.Equal(t, 0x3000, v8) + + t.Run("must get values with type", func(t *testing.T) { + assert.Equal(t, "str", sec.Key("STRING").MustString("404")) + assert.True(t, sec.Key("BOOL").MustBool()) + assert.Equal(t, float64(1.25), sec.Key("FLOAT64").MustFloat64()) + assert.Equal(t, int(10), sec.Key("INT").MustInt()) + assert.Equal(t, int64(10), sec.Key("INT").MustInt64()) + assert.Equal(t, uint(3), sec.Key("UINT").MustUint()) + assert.Equal(t, uint64(3), sec.Key("UINT").MustUint64()) + assert.Equal(t, ti.String(), sec.Key("TIME").MustTime().String()) + assert.Equal(t, 0x3000, sec.Key("HEX_NUMBER").MustInt()) dur, err := time.ParseDuration("2h45m") - So(err, ShouldBeNil) - So(sec.Key("DURATION").MustDuration().Seconds(), ShouldEqual, dur.Seconds()) - - Convey("Must get values with default value", func() { - So(sec.Key("STRING_404").MustString("404"), ShouldEqual, "404") - So(sec.Key("BOOL_404").MustBool(true), ShouldBeTrue) - So(sec.Key("FLOAT64_404").MustFloat64(2.5), ShouldEqual, 2.5) - So(sec.Key("INT_404").MustInt(15), ShouldEqual, 15) - So(sec.Key("INT64_404").MustInt64(15), ShouldEqual, 15) - So(sec.Key("UINT_404").MustUint(6), ShouldEqual, 6) - So(sec.Key("UINT64_404").MustUint64(6), ShouldEqual, 6) - So(sec.Key("HEX_NUMBER_404").MustInt(0x3001), ShouldEqual, 0x3001) - - t, err := time.Parse(time.RFC3339, "2014-01-01T20:17:05Z") - So(err, ShouldBeNil) - So(sec.Key("TIME_404").MustTime(t).String(), ShouldEqual, t.String()) - - So(sec.Key("DURATION_404").MustDuration(dur).Seconds(), ShouldEqual, dur.Seconds()) - - Convey("Must should set default as key value", func() { - So(sec.Key("STRING_404").String(), ShouldEqual, "404") - So(sec.Key("BOOL_404").String(), ShouldEqual, "true") - So(sec.Key("FLOAT64_404").String(), ShouldEqual, "2.5") - So(sec.Key("INT_404").String(), ShouldEqual, "15") - So(sec.Key("INT64_404").String(), ShouldEqual, "15") - So(sec.Key("UINT_404").String(), ShouldEqual, "6") - So(sec.Key("UINT64_404").String(), ShouldEqual, "6") - So(sec.Key("TIME_404").String(), ShouldEqual, "2014-01-01T20:17:05Z") - So(sec.Key("DURATION_404").String(), ShouldEqual, "2h45m0s") - So(sec.Key("HEX_NUMBER_404").String(), ShouldEqual, "12289") + require.NoError(t, err) + assert.Equal(t, dur.Seconds(), sec.Key("DURATION").MustDuration().Seconds()) + + t.Run("must get values with default value", func(t *testing.T) { + assert.Equal(t, "404", sec.Key("STRING_404").MustString("404")) + assert.True(t, sec.Key("BOOL_404").MustBool(true)) + assert.Equal(t, float64(2.5), sec.Key("FLOAT64_404").MustFloat64(2.5)) + assert.Equal(t, int(15), sec.Key("INT_404").MustInt(15)) + assert.Equal(t, int64(15), sec.Key("INT64_404").MustInt64(15)) + assert.Equal(t, uint(6), sec.Key("UINT_404").MustUint(6)) + assert.Equal(t, uint64(6), sec.Key("UINT64_404").MustUint64(6)) + assert.Equal(t, 0x3001, sec.Key("HEX_NUMBER_404").MustInt(0x3001)) + + ti, err := time.Parse(time.RFC3339, "2014-01-01T20:17:05Z") + require.NoError(t, err) + assert.Equal(t, ti.String(), sec.Key("TIME_404").MustTime(ti).String()) + + assert.Equal(t, dur.Seconds(), sec.Key("DURATION_404").MustDuration(dur).Seconds()) + + t.Run("must should set default as key value", func(t *testing.T) { + assert.Equal(t, "404", sec.Key("STRING_404").String()) + assert.Equal(t, "true", sec.Key("BOOL_404").String()) + assert.Equal(t, "2.5", sec.Key("FLOAT64_404").String()) + assert.Equal(t, "15", sec.Key("INT_404").String()) + assert.Equal(t, "15", sec.Key("INT64_404").String()) + assert.Equal(t, "6", sec.Key("UINT_404").String()) + assert.Equal(t, "6", sec.Key("UINT64_404").String()) + assert.Equal(t, "2014-01-01T20:17:05Z", sec.Key("TIME_404").String()) + assert.Equal(t, "2h45m0s", sec.Key("DURATION_404").String()) + assert.Equal(t, "12289", sec.Key("HEX_NUMBER_404").String()) }) }) }) }) - Convey("Get value with candidates", func() { + t.Run("get value with candidates", func(t *testing.T) { sec := f.Section("types") - So(sec.Key("STRING").In("", []string{"str", "arr", "types"}), ShouldEqual, "str") - So(sec.Key("FLOAT64").InFloat64(0, []float64{1.25, 2.5, 3.75}), ShouldEqual, 1.25) - So(sec.Key("INT").InInt(0, []int{10, 20, 30}), ShouldEqual, 10) - So(sec.Key("INT").InInt64(0, []int64{10, 20, 30}), ShouldEqual, 10) - So(sec.Key("UINT").InUint(0, []uint{3, 6, 9}), ShouldEqual, 3) - So(sec.Key("UINT").InUint64(0, []uint64{3, 6, 9}), ShouldEqual, 3) + assert.Equal(t, "str", sec.Key("STRING").In("", []string{"str", "arr", "types"})) + assert.Equal(t, float64(1.25), sec.Key("FLOAT64").InFloat64(0, []float64{1.25, 2.5, 3.75})) + assert.Equal(t, int(10), sec.Key("INT").InInt(0, []int{10, 20, 30})) + assert.Equal(t, int64(10), sec.Key("INT").InInt64(0, []int64{10, 20, 30})) + assert.Equal(t, uint(3), sec.Key("UINT").InUint(0, []uint{3, 6, 9})) + assert.Equal(t, uint64(3), sec.Key("UINT").InUint64(0, []uint64{3, 6, 9})) zt, err := time.Parse(time.RFC3339, "0001-01-01T01:00:00Z") - So(err, ShouldBeNil) - t, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z") - So(err, ShouldBeNil) - So(sec.Key("TIME").InTime(zt, []time.Time{t, time.Now(), time.Now().Add(1 * time.Second)}).String(), ShouldEqual, t.String()) - - Convey("Get value with candidates and default value", func() { - So(sec.Key("STRING_404").In("str", []string{"str", "arr", "types"}), ShouldEqual, "str") - So(sec.Key("FLOAT64_404").InFloat64(1.25, []float64{1.25, 2.5, 3.75}), ShouldEqual, 1.25) - So(sec.Key("INT_404").InInt(10, []int{10, 20, 30}), ShouldEqual, 10) - So(sec.Key("INT64_404").InInt64(10, []int64{10, 20, 30}), ShouldEqual, 10) - So(sec.Key("UINT_404").InUint(3, []uint{3, 6, 9}), ShouldEqual, 3) - So(sec.Key("UINT_404").InUint64(3, []uint64{3, 6, 9}), ShouldEqual, 3) - So(sec.Key("TIME_404").InTime(t, []time.Time{time.Now(), time.Now(), time.Now().Add(1 * time.Second)}).String(), ShouldEqual, t.String()) + require.NoError(t, err) + ti, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z") + require.NoError(t, err) + assert.Equal(t, ti.String(), sec.Key("TIME").InTime(zt, []time.Time{ti, time.Now(), time.Now().Add(1 * time.Second)}).String()) + + t.Run("get value with candidates and default value", func(t *testing.T) { + assert.Equal(t, "str", sec.Key("STRING_404_2").In("str", []string{"str", "arr", "types"})) + assert.Equal(t, float64(1.25), sec.Key("FLOAT64_404_2").InFloat64(1.25, []float64{1.25, 2.5, 3.75})) + assert.Equal(t, int(10), sec.Key("INT_404_2").InInt(10, []int{10, 20, 30})) + assert.Equal(t, int64(10), sec.Key("INT64_404_2").InInt64(10, []int64{10, 20, 30})) + assert.Equal(t, uint(3), sec.Key("UINT_404_2").InUint(3, []uint{3, 6, 9})) + assert.Equal(t, uint64(3), sec.Key("UINT_404_2").InUint64(3, []uint64{3, 6, 9})) + assert.Equal(t, ti.String(), sec.Key("TIME_404_2").InTime(ti, []time.Time{time.Now(), time.Now(), time.Now().Add(1 * time.Second)}).String()) }) }) - Convey("Get values in range", func() { + t.Run("get values in range", func(t *testing.T) { sec := f.Section("types") - So(sec.Key("FLOAT64").RangeFloat64(0, 1, 2), ShouldEqual, 1.25) - So(sec.Key("INT").RangeInt(0, 10, 20), ShouldEqual, 10) - So(sec.Key("INT").RangeInt64(0, 10, 20), ShouldEqual, 10) + assert.Equal(t, float64(1.25), sec.Key("FLOAT64").RangeFloat64(0, 1, 2)) + assert.Equal(t, int(10), sec.Key("INT").RangeInt(0, 10, 20)) + assert.Equal(t, int64(10), sec.Key("INT").RangeInt64(0, 10, 20)) minT, err := time.Parse(time.RFC3339, "0001-01-01T01:00:00Z") - So(err, ShouldBeNil) + require.NoError(t, err) midT, err := time.Parse(time.RFC3339, "2013-01-01T01:00:00Z") - So(err, ShouldBeNil) + require.NoError(t, err) maxT, err := time.Parse(time.RFC3339, "9999-01-01T01:00:00Z") - So(err, ShouldBeNil) - t, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z") - So(err, ShouldBeNil) - So(sec.Key("TIME").RangeTime(t, minT, maxT).String(), ShouldEqual, t.String()) - - Convey("Get value in range with default value", func() { - So(sec.Key("FLOAT64").RangeFloat64(5, 0, 1), ShouldEqual, 5) - So(sec.Key("INT").RangeInt(7, 0, 5), ShouldEqual, 7) - So(sec.Key("INT").RangeInt64(7, 0, 5), ShouldEqual, 7) - So(sec.Key("TIME").RangeTime(t, minT, midT).String(), ShouldEqual, t.String()) + require.NoError(t, err) + ti, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z") + require.NoError(t, err) + assert.Equal(t, ti.String(), sec.Key("TIME").RangeTime(ti, minT, maxT).String()) + + t.Run("get value in range with default value", func(t *testing.T) { + assert.Equal(t, float64(5), sec.Key("FLOAT64").RangeFloat64(5, 0, 1)) + assert.Equal(t, 7, sec.Key("INT").RangeInt(7, 0, 5)) + assert.Equal(t, int64(7), sec.Key("INT").RangeInt64(7, 0, 5)) + assert.Equal(t, ti.String(), sec.Key("TIME").RangeTime(ti, minT, midT).String()) }) }) - Convey("Get values into slice", func() { + t.Run("get values into slice", func(t *testing.T) { sec := f.Section("array") - So(strings.Join(sec.Key("STRINGS").Strings(","), ","), ShouldEqual, "en,zh,de") - So(len(sec.Key("STRINGS_404").Strings(",")), ShouldEqual, 0) + assert.Equal(t, "en,zh,de", strings.Join(sec.Key("STRINGS").Strings(","), ",")) + assert.Equal(t, 0, len(sec.Key("STRINGS_404").Strings(","))) vals1 := sec.Key("FLOAT64S").Float64s(",") - float64sEqual(vals1, 1.1, 2.2, 3.3) + float64sEqual(t, vals1, 1.1, 2.2, 3.3) vals2 := sec.Key("INTS").Ints(",") - intsEqual(vals2, 1, 2, 3) + intsEqual(t, vals2, 1, 2, 3) vals3 := sec.Key("INTS").Int64s(",") - int64sEqual(vals3, 1, 2, 3) + int64sEqual(t, vals3, 1, 2, 3) vals4 := sec.Key("UINTS").Uints(",") - uintsEqual(vals4, 1, 2, 3) + uintsEqual(t, vals4, 1, 2, 3) vals5 := sec.Key("UINTS").Uint64s(",") - uint64sEqual(vals5, 1, 2, 3) + uint64sEqual(t, vals5, 1, 2, 3) vals6 := sec.Key("BOOLS").Bools(",") - boolsEqual(vals6, true, false, false) + boolsEqual(t, vals6, true, false, false) - t, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z") - So(err, ShouldBeNil) + ti, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z") + require.NoError(t, err) vals7 := sec.Key("TIMES").Times(",") - timesEqual(vals7, t, t, t) + timesEqual(t, vals7, ti, ti, ti) }) - Convey("Test string slice escapes", func() { + t.Run("test string slice escapes", func(t *testing.T) { sec := f.Section("string escapes") - So(sec.Key("key1").Strings(","), ShouldResemble, []string{"value1", "value2", "value3"}) - So(sec.Key("key2").Strings(","), ShouldResemble, []string{"value1, value2"}) - So(sec.Key("key3").Strings(","), ShouldResemble, []string{`val\ue1`, "value2"}) - So(sec.Key("key4").Strings(","), ShouldResemble, []string{`value1\`, `value\\2`}) - So(sec.Key("key5").Strings(",,"), ShouldResemble, []string{"value1,, value2"}) - So(sec.Key("key6").Strings(" "), ShouldResemble, []string{"aaa", "bbb and space", "ccc"}) + assert.Equal(t, []string{"value1", "value2", "value3"}, sec.Key("key1").Strings(",")) + assert.Equal(t, []string{"value1, value2"}, sec.Key("key2").Strings(",")) + assert.Equal(t, []string{`val\ue1`, "value2"}, sec.Key("key3").Strings(",")) + assert.Equal(t, []string{`value1\`, `value\\2`}, sec.Key("key4").Strings(",")) + assert.Equal(t, []string{"value1,, value2"}, sec.Key("key5").Strings(",,")) + assert.Equal(t, []string{"aaa", "bbb and space", "ccc"}, sec.Key("key6").Strings(" ")) }) - Convey("Get valid values into slice", func() { + t.Run("get valid values into slice", func(t *testing.T) { sec := f.Section("array") vals1 := sec.Key("FLOAT64S").ValidFloat64s(",") - float64sEqual(vals1, 1.1, 2.2, 3.3) + float64sEqual(t, vals1, 1.1, 2.2, 3.3) vals2 := sec.Key("INTS").ValidInts(",") - intsEqual(vals2, 1, 2, 3) + intsEqual(t, vals2, 1, 2, 3) vals3 := sec.Key("INTS").ValidInt64s(",") - int64sEqual(vals3, 1, 2, 3) + int64sEqual(t, vals3, 1, 2, 3) vals4 := sec.Key("UINTS").ValidUints(",") - uintsEqual(vals4, 1, 2, 3) + uintsEqual(t, vals4, 1, 2, 3) vals5 := sec.Key("UINTS").ValidUint64s(",") - uint64sEqual(vals5, 1, 2, 3) + uint64sEqual(t, vals5, 1, 2, 3) vals6 := sec.Key("BOOLS").ValidBools(",") - boolsEqual(vals6, true, false, false) + boolsEqual(t, vals6, true, false, false) - t, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z") - So(err, ShouldBeNil) + ti, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z") + require.NoError(t, err) vals7 := sec.Key("TIMES").ValidTimes(",") - timesEqual(vals7, t, t, t) + timesEqual(t, vals7, ti, ti, ti) }) - Convey("Get values one type into slice of another type", func() { + t.Run("get values one type into slice of another type", func(t *testing.T) { sec := f.Section("array") vals1 := sec.Key("STRINGS").ValidFloat64s(",") - So(vals1, ShouldBeEmpty) + assert.Empty(t, vals1) vals2 := sec.Key("STRINGS").ValidInts(",") - So(vals2, ShouldBeEmpty) + assert.Empty(t, vals2) vals3 := sec.Key("STRINGS").ValidInt64s(",") - So(vals3, ShouldBeEmpty) + assert.Empty(t, vals3) vals4 := sec.Key("STRINGS").ValidUints(",") - So(vals4, ShouldBeEmpty) + assert.Empty(t, vals4) vals5 := sec.Key("STRINGS").ValidUint64s(",") - So(vals5, ShouldBeEmpty) + assert.Empty(t, vals5) vals6 := sec.Key("STRINGS").ValidBools(",") - So(vals6, ShouldBeEmpty) + assert.Empty(t, vals6) vals7 := sec.Key("STRINGS").ValidTimes(",") - So(vals7, ShouldBeEmpty) + assert.Empty(t, vals7) }) - Convey("Get valid values into slice without errors", func() { + t.Run("get valid values into slice without errors", func(t *testing.T) { sec := f.Section("array") vals1, err := sec.Key("FLOAT64S").StrictFloat64s(",") - So(err, ShouldBeNil) - float64sEqual(vals1, 1.1, 2.2, 3.3) + require.NoError(t, err) + float64sEqual(t, vals1, 1.1, 2.2, 3.3) vals2, err := sec.Key("INTS").StrictInts(",") - So(err, ShouldBeNil) - intsEqual(vals2, 1, 2, 3) + require.NoError(t, err) + intsEqual(t, vals2, 1, 2, 3) vals3, err := sec.Key("INTS").StrictInt64s(",") - So(err, ShouldBeNil) - int64sEqual(vals3, 1, 2, 3) + require.NoError(t, err) + int64sEqual(t, vals3, 1, 2, 3) vals4, err := sec.Key("UINTS").StrictUints(",") - So(err, ShouldBeNil) - uintsEqual(vals4, 1, 2, 3) + require.NoError(t, err) + uintsEqual(t, vals4, 1, 2, 3) vals5, err := sec.Key("UINTS").StrictUint64s(",") - So(err, ShouldBeNil) - uint64sEqual(vals5, 1, 2, 3) + require.NoError(t, err) + uint64sEqual(t, vals5, 1, 2, 3) vals6, err := sec.Key("BOOLS").StrictBools(",") - So(err, ShouldBeNil) - boolsEqual(vals6, true, false, false) + require.NoError(t, err) + boolsEqual(t, vals6, true, false, false) - t, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z") - So(err, ShouldBeNil) + ti, err := time.Parse(time.RFC3339, "2015-01-01T20:17:05Z") + require.NoError(t, err) vals7, err := sec.Key("TIMES").StrictTimes(",") - So(err, ShouldBeNil) - timesEqual(vals7, t, t, t) + require.NoError(t, err) + timesEqual(t, vals7, ti, ti, ti) }) - Convey("Get invalid values into slice", func() { + t.Run("get invalid values into slice", func(t *testing.T) { sec := f.Section("array") vals1, err := sec.Key("STRINGS").StrictFloat64s(",") - So(vals1, ShouldBeEmpty) - So(err, ShouldNotBeNil) + assert.Empty(t, vals1) + assert.Error(t, err) vals2, err := sec.Key("STRINGS").StrictInts(",") - So(vals2, ShouldBeEmpty) - So(err, ShouldNotBeNil) + assert.Empty(t, vals2) + assert.Error(t, err) vals3, err := sec.Key("STRINGS").StrictInt64s(",") - So(vals3, ShouldBeEmpty) - So(err, ShouldNotBeNil) + assert.Empty(t, vals3) + assert.Error(t, err) vals4, err := sec.Key("STRINGS").StrictUints(",") - So(vals4, ShouldBeEmpty) - So(err, ShouldNotBeNil) + assert.Empty(t, vals4) + assert.Error(t, err) vals5, err := sec.Key("STRINGS").StrictUint64s(",") - So(vals5, ShouldBeEmpty) - So(err, ShouldNotBeNil) + assert.Empty(t, vals5) + assert.Error(t, err) vals6, err := sec.Key("STRINGS").StrictBools(",") - So(vals6, ShouldBeEmpty) - So(err, ShouldNotBeNil) + assert.Empty(t, vals6) + assert.Error(t, err) vals7, err := sec.Key("STRINGS").StrictTimes(",") - So(vals7, ShouldBeEmpty) - So(err, ShouldNotBeNil) + assert.Empty(t, vals7) + assert.Error(t, err) }) }) } func TestKey_StringsWithShadows(t *testing.T) { - Convey("Get strings of shadows of a key", t, func() { + t.Run("get strings of shadows of a key", func(t *testing.T) { f, err := ini.ShadowLoad([]byte("")) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) k, err := f.Section("").NewKey("NUMS", "1,2") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) k, err = f.Section("").NewKey("NUMS", "4,5,6") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) - So(k.StringsWithShadows(","), ShouldResemble, []string{"1", "2", "4", "5", "6"}) + assert.Equal(t, []string{"1", "2", "4", "5", "6"}, k.StringsWithShadows(",")) }) } func TestKey_SetValue(t *testing.T) { - Convey("Set value of key", t, func() { + t.Run("set value of key", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) - So(k.Value(), ShouldEqual, "ini") + require.NoError(t, err) + require.NotNil(t, k) + assert.Equal(t, "ini", k.Value()) k.SetValue("ini.v1") - So(k.Value(), ShouldEqual, "ini.v1") + assert.Equal(t, "ini.v1", k.Value()) }) } func TestKey_NestedValues(t *testing.T) { - Convey("Read and write nested values", t, func() { + t.Run("read and write nested values", func(t *testing.T) { f, err := ini.LoadSources(ini.LoadOptions{ AllowNestedValues: true, }, []byte(` @@ -550,48 +566,50 @@ region = us-west-2 s3 = max_concurrent_requests=10 max_queue_size=1000`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("s3").NestedValues(), ShouldResemble, []string{"max_concurrent_requests=10", "max_queue_size=1000"}) + assert.Equal(t, []string{"max_concurrent_requests=10", "max_queue_size=1000"}, f.Section("").Key("s3").NestedValues()) var buf bytes.Buffer _, err = f.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `aws_access_key_id = foo + require.NoError(t, err) + assert.Equal(t, `aws_access_key_id = foo aws_secret_access_key = bar region = us-west-2 s3 = max_concurrent_requests=10 max_queue_size=1000 -`) +`, + buf.String(), + ) }) } func TestRecursiveValues(t *testing.T) { - Convey("Recursive values should not reflect on same key", t, func() { + t.Run("recursive values should not reflect on same key", func(t *testing.T) { f, err := ini.Load([]byte(` NAME = ini expires = yes [package] NAME = %(NAME)s expires = %(expires)s`)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("package").Key("NAME").String(), ShouldEqual, "ini") - So(f.Section("package").Key("expires").String(), ShouldEqual, "yes") + assert.Equal(t, "ini", f.Section("package").Key("NAME").String()) + assert.Equal(t, "yes", f.Section("package").Key("expires").String()) }) - Convey("Recursive value with no target found", t, func() { + t.Run("recursive value with no target found", func(t *testing.T) { f, err := ini.Load([]byte(` [foo] bar = %(missing)s `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("foo").Key("bar").String(), ShouldEqual, "%(missing)s") + assert.Equal(t, "%(missing)s", f.Section("foo").Key("bar").String()) }) } diff --git a/parser_test.go b/parser_test.go index bd3c6ac..3462807 100644 --- a/parser_test.go +++ b/parser_test.go @@ -17,61 +17,63 @@ package ini_test import ( "testing" - . "github.com/smartystreets/goconvey/convey" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "gopkg.in/ini.v1" ) func TestBOM(t *testing.T) { - Convey("Test handling BOM", t, func() { - Convey("UTF-8-BOM", func() { + t.Run("test handling BOM", func(t *testing.T) { + t.Run("UTF-8-BOM", func(t *testing.T) { f, err := ini.Load("testdata/UTF-8-BOM.ini") - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("author").Key("E-MAIL").String(), ShouldEqual, "example@email.com") + assert.Equal(t, "example@email.com", f.Section("author").Key("E-MAIL").String()) }) - Convey("UTF-16-LE-BOM", func() { + t.Run("UTF-16-LE-BOM", func(t *testing.T) { f, err := ini.Load("testdata/UTF-16-LE-BOM.ini") - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) }) - Convey("UTF-16-BE-BOM", func() { + t.Run("UTF-16-BE-BOM", func(t *testing.T) { }) }) } func TestBadLoad(t *testing.T) { - Convey("Load with bad data", t, func() { - Convey("Bad section name", func() { + t.Run("load with bad data", func(t *testing.T) { + t.Run("bad section name", func(t *testing.T) { _, err := ini.Load([]byte("[]")) - So(err, ShouldNotBeNil) + require.Error(t, err) _, err = ini.Load([]byte("[")) - So(err, ShouldNotBeNil) + require.Error(t, err) }) - Convey("Bad keys", func() { + t.Run("bad keys", func(t *testing.T) { _, err := ini.Load([]byte(`"""name`)) - So(err, ShouldNotBeNil) + require.Error(t, err) _, err = ini.Load([]byte(`"""name"""`)) - So(err, ShouldNotBeNil) + require.Error(t, err) _, err = ini.Load([]byte(`""=1`)) - So(err, ShouldNotBeNil) + require.Error(t, err) _, err = ini.Load([]byte(`=`)) - So(err, ShouldNotBeNil) + require.Error(t, err) _, err = ini.Load([]byte(`name`)) - So(err, ShouldNotBeNil) + require.Error(t, err) }) - Convey("Bad values", func() { + t.Run("bad values", func(t *testing.T) { _, err := ini.Load([]byte(`name="""Unknwon`)) - So(err, ShouldNotBeNil) + require.Error(t, err) }) }) } diff --git a/section_test.go b/section_test.go index 37da867..9cf3189 100644 --- a/section_test.go +++ b/section_test.go @@ -17,261 +17,263 @@ package ini_test import ( "testing" - . "github.com/smartystreets/goconvey/convey" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "gopkg.in/ini.v1" ) func TestSection_SetBody(t *testing.T) { - Convey("Set body of raw section", t, func() { + t.Run("set body of raw section", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) sec, err := f.NewRawSection("comments", `1111111111111111111000000000000000001110000 111111111111111111100000000000111000000000`) - So(err, ShouldBeNil) - So(sec, ShouldNotBeNil) - So(sec.Body(), ShouldEqual, `1111111111111111111000000000000000001110000 -111111111111111111100000000000111000000000`) + require.NoError(t, err) + require.NotNil(t, sec) + assert.Equal(t, `1111111111111111111000000000000000001110000 +111111111111111111100000000000111000000000`, sec.Body()) sec.SetBody("1111111111111111111000000000000000001110000") - So(sec.Body(), ShouldEqual, `1111111111111111111000000000000000001110000`) + assert.Equal(t, `1111111111111111111000000000000000001110000`, sec.Body()) - Convey("Set for non-raw section", func() { + t.Run("set for non-raw section", func(t *testing.T) { sec, err := f.NewSection("author") - So(err, ShouldBeNil) - So(sec, ShouldNotBeNil) - So(sec.Body(), ShouldBeEmpty) + require.NoError(t, err) + require.NotNil(t, sec) + assert.Empty(t, sec.Body()) sec.SetBody("1111111111111111111000000000000000001110000") - So(sec.Body(), ShouldBeEmpty) + assert.Empty(t, sec.Body()) }) }) } func TestSection_NewKey(t *testing.T) { - Convey("Create a new key", t, func() { + t.Run("create a new key", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) - So(k.Name(), ShouldEqual, "NAME") - So(k.Value(), ShouldEqual, "ini") + require.NoError(t, err) + require.NotNil(t, k) + assert.Equal(t, "NAME", k.Name()) + assert.Equal(t, "ini", k.Value()) - Convey("With duplicated name", func() { + t.Run("with duplicated name", func(t *testing.T) { k, err := f.Section("").NewKey("NAME", "ini.v1") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) // Overwrite previous existed key - So(k.Value(), ShouldEqual, "ini.v1") + assert.Equal(t, "ini.v1", k.Value()) }) - Convey("With empty string", func() { + t.Run("with empty string", func(t *testing.T) { _, err := f.Section("").NewKey("", "") - So(err, ShouldNotBeNil) + require.Error(t, err) }) }) - Convey("Create keys with same name and allow shadow", t, func() { + t.Run("create keys with same name and allow shadow", func(t *testing.T) { f, err := ini.ShadowLoad([]byte("")) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) k, err = f.Section("").NewKey("NAME", "ini.v1") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) - So(k.ValueWithShadows(), ShouldResemble, []string{"ini", "ini.v1"}) + assert.Equal(t, []string{"ini", "ini.v1"}, k.ValueWithShadows()) }) } func TestSection_NewBooleanKey(t *testing.T) { - Convey("Create a new boolean key", t, func() { + t.Run("create a new boolean key", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("").NewBooleanKey("start-ssh-server") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) - So(k.Name(), ShouldEqual, "start-ssh-server") - So(k.Value(), ShouldEqual, "true") + require.NoError(t, err) + require.NotNil(t, k) + assert.Equal(t, "start-ssh-server", k.Name()) + assert.Equal(t, "true", k.Value()) - Convey("With empty string", func() { + t.Run("with empty string", func(t *testing.T) { _, err := f.Section("").NewBooleanKey("") - So(err, ShouldNotBeNil) + require.Error(t, err) }) }) } func TestSection_GetKey(t *testing.T) { - Convey("Get a key", t, func() { + t.Run("get a key", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) k, err = f.Section("").GetKey("NAME") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) - So(k.Name(), ShouldEqual, "NAME") - So(k.Value(), ShouldEqual, "ini") + require.NoError(t, err) + require.NotNil(t, k) + assert.Equal(t, "NAME", k.Name()) + assert.Equal(t, "ini", k.Value()) - Convey("Key not exists", func() { + t.Run("key not exists", func(t *testing.T) { _, err := f.Section("").GetKey("404") - So(err, ShouldNotBeNil) + require.Error(t, err) }) - Convey("Key exists in parent section", func() { + t.Run("key exists in parent section", func(t *testing.T) { k, err := f.Section("parent").NewKey("AGE", "18") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) k, err = f.Section("parent.child.son").GetKey("AGE") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) - So(k.Value(), ShouldEqual, "18") + require.NoError(t, err) + require.NotNil(t, k) + assert.Equal(t, "18", k.Value()) }) }) } func TestSection_HasKey(t *testing.T) { - Convey("Check if a key exists", t, func() { + t.Run("check if a key exists", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) - So(f.Section("").HasKey("NAME"), ShouldBeTrue) - So(f.Section("").HasKey("NAME"), ShouldBeTrue) - So(f.Section("").HasKey("404"), ShouldBeFalse) - So(f.Section("").HasKey("404"), ShouldBeFalse) + assert.True(t, f.Section("").HasKey("NAME")) + assert.True(t, f.Section("").HasKey("NAME")) + assert.False(t, f.Section("").HasKey("404")) + assert.False(t, f.Section("").HasKey("404")) }) } func TestSection_HasValue(t *testing.T) { - Convey("Check if contains a value in any key", t, func() { + t.Run("check if contains a value in any key", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) - So(f.Section("").HasValue("ini"), ShouldBeTrue) - So(f.Section("").HasValue("404"), ShouldBeFalse) + assert.True(t, f.Section("").HasValue("ini")) + assert.False(t, f.Section("").HasValue("404")) }) } func TestSection_Key(t *testing.T) { - Convey("Get a key", t, func() { + t.Run("get a key", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) k = f.Section("").Key("NAME") - So(k, ShouldNotBeNil) - So(k.Name(), ShouldEqual, "NAME") - So(k.Value(), ShouldEqual, "ini") + require.NotNil(t, k) + assert.Equal(t, "NAME", k.Name()) + assert.Equal(t, "ini", k.Value()) - Convey("Key not exists", func() { + t.Run("key not exists", func(t *testing.T) { k := f.Section("").Key("404") - So(k, ShouldNotBeNil) - So(k.Name(), ShouldEqual, "404") + require.NotNil(t, k) + assert.Equal(t, "404", k.Name()) }) - Convey("Key exists in parent section", func() { + t.Run("key exists in parent section", func(t *testing.T) { k, err := f.Section("parent").NewKey("AGE", "18") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) k = f.Section("parent.child.son").Key("AGE") - So(k, ShouldNotBeNil) - So(k.Value(), ShouldEqual, "18") + require.NotNil(t, k) + assert.Equal(t, "18", k.Value()) }) }) } func TestSection_Keys(t *testing.T) { - Convey("Get all keys in a section", t, func() { + t.Run("get all keys in a section", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) k, err = f.Section("").NewKey("VERSION", "v1") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) k, err = f.Section("").NewKey("IMPORT_PATH", "gopkg.in/ini.v1") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) keys := f.Section("").Keys() names := []string{"NAME", "VERSION", "IMPORT_PATH"} - So(len(keys), ShouldEqual, len(names)) + assert.Equal(t, len(names), len(keys)) for i, name := range names { - So(keys[i].Name(), ShouldEqual, name) + assert.Equal(t, name, keys[i].Name()) } }) } func TestSection_ParentKeys(t *testing.T) { - Convey("Get all keys of parent sections", t, func() { + t.Run("get all keys of parent sections", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("package").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) k, err = f.Section("package").NewKey("VERSION", "v1") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) k, err = f.Section("package").NewKey("IMPORT_PATH", "gopkg.in/ini.v1") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) keys := f.Section("package.sub.sub2").ParentKeys() names := []string{"NAME", "VERSION", "IMPORT_PATH"} - So(len(keys), ShouldEqual, len(names)) + assert.Equal(t, len(names), len(keys)) for i, name := range names { - So(keys[i].Name(), ShouldEqual, name) + assert.Equal(t, name, keys[i].Name()) } }) } func TestSection_KeyStrings(t *testing.T) { - Convey("Get all key names in a section", t, func() { + t.Run("get all key names in a section", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) k, err = f.Section("").NewKey("VERSION", "v1") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) k, err = f.Section("").NewKey("IMPORT_PATH", "gopkg.in/ini.v1") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) - So(f.Section("").KeyStrings(), ShouldResemble, []string{"NAME", "VERSION", "IMPORT_PATH"}) + assert.Equal(t, []string{"NAME", "VERSION", "IMPORT_PATH"}, f.Section("").KeyStrings()) }) } func TestSection_KeyHash(t *testing.T) { - Convey("Get clone of key hash", t, func() { + t.Run("get clone of key hash", func(t *testing.T) { f, err := ini.Load([]byte(` key = one [log] @@ -283,10 +285,10 @@ key = two name = app2 file = b.log `)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.Section("").Key("key").String(), ShouldEqual, "two") + assert.Equal(t, "two", f.Section("").Key("key").String()) hash := f.Section("log").KeysHash() relation := map[string]string{ @@ -294,22 +296,22 @@ file = b.log "file": "b.log", } for k, v := range hash { - So(v, ShouldEqual, relation[k]) + assert.Equal(t, relation[k], v) } }) } func TestSection_DeleteKey(t *testing.T) { - Convey("Delete a key", t, func() { + t.Run("delete a key", func(t *testing.T) { f := ini.Empty() - So(f, ShouldNotBeNil) + require.NotNil(t, f) k, err := f.Section("").NewKey("NAME", "ini") - So(err, ShouldBeNil) - So(k, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, k) - So(f.Section("").HasKey("NAME"), ShouldBeTrue) + assert.True(t, f.Section("").HasKey("NAME")) f.Section("").DeleteKey("NAME") - So(f.Section("").HasKey("NAME"), ShouldBeFalse) + assert.False(t, f.Section("").HasKey("NAME")) }) } diff --git a/struct_test.go b/struct_test.go index 65e6925..e2855c6 100644 --- a/struct_test.go +++ b/struct_test.go @@ -21,7 +21,8 @@ import ( "testing" "time" - . "github.com/smartystreets/goconvey/convey" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "gopkg.in/ini.v1" ) @@ -215,88 +216,88 @@ Cities = ` func Test_MapToStruct(t *testing.T) { - Convey("Map to struct", t, func() { - Convey("Map file to struct", func() { + t.Run("map to struct", func(t *testing.T) { + t.Run("map file to struct", func(t *testing.T) { ts := new(testStruct) - So(ini.MapTo(ts, []byte(confDataStruct)), ShouldBeNil) + assert.NoError(t, ini.MapTo(ts, []byte(confDataStruct))) - So(ts.Name, ShouldEqual, "Unknwon") - So(ts.Age, ShouldEqual, 21) - So(ts.Male, ShouldBeTrue) - So(ts.Money, ShouldEqual, 1.25) - So(ts.Unsigned, ShouldEqual, 3) + assert.Equal(t, "Unknwon", ts.Name) + assert.Equal(t, 21, ts.Age) + assert.True(t, ts.Male) + assert.Equal(t, 1.25, ts.Money) + assert.Equal(t, uint(3), ts.Unsigned) - t, err := time.Parse(time.RFC3339, "1993-10-07T20:17:05Z") - So(err, ShouldBeNil) - So(ts.Born.String(), ShouldEqual, t.String()) + ti, err := time.Parse(time.RFC3339, "1993-10-07T20:17:05Z") + require.NoError(t, err) + assert.Equal(t, ti.String(), ts.Born.String()) dur, err := time.ParseDuration("2h45m") - So(err, ShouldBeNil) - So(ts.Time.Seconds(), ShouldEqual, dur.Seconds()) - - So(ts.OldVersionTime*time.Second, ShouldEqual, 30*time.Second) - - So(strings.Join(ts.Others.Cities, ","), ShouldEqual, "HangZhou,Boston") - So(ts.Others.Visits[0].String(), ShouldEqual, t.String()) - So(fmt.Sprint(ts.Others.Years), ShouldEqual, "[1993 1994]") - So(fmt.Sprint(ts.Others.Numbers), ShouldEqual, "[10010 10086]") - So(fmt.Sprint(ts.Others.Ages), ShouldEqual, "[18 19]") - So(fmt.Sprint(ts.Others.Populations), ShouldEqual, "[12345678 98765432]") - So(fmt.Sprint(ts.Others.Coordinates), ShouldEqual, "[192.168 10.11]") - So(fmt.Sprint(ts.Others.Flags), ShouldEqual, "[true false]") - So(ts.Others.Note, ShouldEqual, "Hello world!") - So(ts.TestEmbeded.GPA, ShouldEqual, 2.8) - - So(strings.Join(ts.OthersPtr.Cities, ","), ShouldEqual, "HangZhou,Boston") - So(ts.OthersPtr.Visits[0].String(), ShouldEqual, t.String()) - So(fmt.Sprint(ts.OthersPtr.Years), ShouldEqual, "[1993 1994]") - So(fmt.Sprint(ts.OthersPtr.Numbers), ShouldEqual, "[10010 10086]") - So(fmt.Sprint(ts.OthersPtr.Ages), ShouldEqual, "[18 19]") - So(fmt.Sprint(ts.OthersPtr.Populations), ShouldEqual, "[12345678 98765432]") - So(fmt.Sprint(ts.OthersPtr.Coordinates), ShouldEqual, "[192.168 10.11]") - So(fmt.Sprint(ts.OthersPtr.Flags), ShouldEqual, "[true false]") - So(ts.OthersPtr.Note, ShouldEqual, "Hello world!") - - So(ts.NilPtr, ShouldBeNil) - - So(*ts.BoolPtr, ShouldEqual, false) - So(ts.BoolPtrNil, ShouldEqual, nil) - So(*ts.FloatPtr, ShouldEqual, 0) - So(ts.FloatPtrNil, ShouldEqual, nil) - So(*ts.IntPtr, ShouldEqual, 0) - So(ts.IntPtrNil, ShouldEqual, nil) - So(*ts.UintPtr, ShouldEqual, 0) - So(ts.UintPtrNil, ShouldEqual, nil) - So(*ts.StringPtr, ShouldEqual, "") - So(ts.StringPtrNil, ShouldEqual, nil) - So(*ts.TimePtr, ShouldNotEqual, nil) - So(ts.TimePtrNil, ShouldEqual, nil) - So(*ts.DurationPtr, ShouldEqual, 0) - So(ts.DurationPtrNil, ShouldEqual, nil) + require.NoError(t, err) + assert.Equal(t, dur.Seconds(), ts.Time.Seconds()) + + assert.Equal(t, 30*time.Second, ts.OldVersionTime*time.Second) + + assert.Equal(t, "HangZhou,Boston", strings.Join(ts.Others.Cities, ",")) + assert.Equal(t, ti.String(), ts.Others.Visits[0].String()) + assert.Equal(t, "[1993 1994]", fmt.Sprint(ts.Others.Years)) + assert.Equal(t, "[10010 10086]", fmt.Sprint(ts.Others.Numbers)) + assert.Equal(t, "[18 19]", fmt.Sprint(ts.Others.Ages)) + assert.Equal(t, "[12345678 98765432]", fmt.Sprint(ts.Others.Populations)) + assert.Equal(t, "[192.168 10.11]", fmt.Sprint(ts.Others.Coordinates)) + assert.Equal(t, "[true false]", fmt.Sprint(ts.Others.Flags)) + assert.Equal(t, "Hello world!", ts.Others.Note) + assert.Equal(t, 2.8, ts.TestEmbeded.GPA) + + assert.Equal(t, "HangZhou,Boston", strings.Join(ts.OthersPtr.Cities, ",")) + assert.Equal(t, ti.String(), ts.OthersPtr.Visits[0].String()) + assert.Equal(t, "[1993 1994]", fmt.Sprint(ts.OthersPtr.Years)) + assert.Equal(t, "[10010 10086]", fmt.Sprint(ts.OthersPtr.Numbers)) + assert.Equal(t, "[18 19]", fmt.Sprint(ts.OthersPtr.Ages)) + assert.Equal(t, "[12345678 98765432]", fmt.Sprint(ts.OthersPtr.Populations)) + assert.Equal(t, "[192.168 10.11]", fmt.Sprint(ts.OthersPtr.Coordinates)) + assert.Equal(t, "[true false]", fmt.Sprint(ts.OthersPtr.Flags)) + assert.Equal(t, "Hello world!", ts.OthersPtr.Note) + + assert.Nil(t, ts.NilPtr) + + assert.Equal(t, false, *ts.BoolPtr) + assert.Nil(t, ts.BoolPtrNil) + assert.Equal(t, float64(0), *ts.FloatPtr) + assert.Nil(t, ts.FloatPtrNil) + assert.Equal(t, 0, *ts.IntPtr) + assert.Nil(t, ts.IntPtrNil) + assert.Equal(t, uint(0), *ts.UintPtr) + assert.Nil(t, ts.UintPtrNil) + assert.Equal(t, "", *ts.StringPtr) + assert.Nil(t, ts.StringPtrNil) + assert.NotNil(t, *ts.TimePtr) + assert.Nil(t, ts.TimePtrNil) + assert.Equal(t, time.Duration(0), *ts.DurationPtr) + assert.Nil(t, ts.DurationPtrNil) }) - Convey("Map section to struct", func() { + t.Run("map section to struct", func(t *testing.T) { foobar := new(fooBar) f, err := ini.Load([]byte(confDataStruct)) - So(err, ShouldBeNil) + require.NoError(t, err) - So(f.Section("foo.bar").MapTo(foobar), ShouldBeNil) - So(foobar.Here, ShouldEqual, "there") - So(foobar.When, ShouldEqual, "then") + assert.NoError(t, f.Section("foo.bar").MapTo(foobar)) + assert.Equal(t, "there", foobar.Here) + assert.Equal(t, "then", foobar.When) }) - Convey("Map to non-pointer struct", func() { + t.Run("map to non-pointer struct", func(t *testing.T) { f, err := ini.Load([]byte(confDataStruct)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) - So(f.MapTo(testStruct{}), ShouldNotBeNil) + assert.Error(t, f.MapTo(testStruct{})) }) - Convey("Map to unsupported type", func() { + t.Run("map to unsupported type", func(t *testing.T) { f, err := ini.Load([]byte(confDataStruct)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) f.NameMapper = func(raw string) string { if raw == "Byte" { @@ -304,64 +305,64 @@ func Test_MapToStruct(t *testing.T) { } return raw } - So(f.MapTo(&unsupport{}), ShouldNotBeNil) - So(f.MapTo(&unsupport2{}), ShouldNotBeNil) - So(f.MapTo(&unsupport4{}), ShouldNotBeNil) + assert.Error(t, f.MapTo(&unsupport{})) + assert.Error(t, f.MapTo(&unsupport2{})) + assert.Error(t, f.MapTo(&unsupport4{})) }) - Convey("Map to omitempty field", func() { + t.Run("map to omitempty field", func(t *testing.T) { ts := new(testStruct) - So(ini.MapTo(ts, []byte(confDataStruct)), ShouldBeNil) + assert.NoError(t, ini.MapTo(ts, []byte(confDataStruct))) - So(ts.Omitted, ShouldEqual, true) + assert.Equal(t, true, ts.Omitted) }) - Convey("Map with shadows", func() { + t.Run("map with shadows", func(t *testing.T) { f, err := ini.LoadSources(ini.LoadOptions{AllowShadows: true}, []byte(confDataStruct)) - So(err, ShouldBeNil) + require.NoError(t, err) ts := new(testStruct) - So(f.MapTo(ts), ShouldBeNil) + assert.NoError(t, f.MapTo(ts)) - So(strings.Join(ts.Shadows, " "), ShouldEqual, "1 2 3 4") - So(fmt.Sprintf("%v", ts.ShadowInts), ShouldEqual, "[1 2 3 4]") + assert.Equal(t, "1 2 3 4", strings.Join(ts.Shadows, " ")) + assert.Equal(t, "[1 2 3 4]", fmt.Sprintf("%v", ts.ShadowInts)) }) - Convey("Map from invalid data source", func() { - So(ini.MapTo(&testStruct{}, "hi"), ShouldNotBeNil) + t.Run("map from invalid data source", func(t *testing.T) { + assert.Error(t, ini.MapTo(&testStruct{}, "hi")) }) - Convey("Map to wrong types and gain default values", func() { + t.Run("map to wrong types and gain default values", func(t *testing.T) { f, err := ini.Load([]byte(invalidDataConfStruct)) - So(err, ShouldBeNil) - - t, err := time.Parse(time.RFC3339, "1993-10-07T20:17:05Z") - So(err, ShouldBeNil) - dv := &defaultValue{"Joe", 10, true, nil, 1.25, t, []string{"HangZhou", "Boston"}} - So(f.MapTo(dv), ShouldBeNil) - So(dv.Name, ShouldEqual, "Joe") - So(dv.Age, ShouldEqual, 10) - So(dv.Male, ShouldBeTrue) - So(dv.Money, ShouldEqual, 1.25) - So(dv.Born.String(), ShouldEqual, t.String()) - So(strings.Join(dv.Cities, ","), ShouldEqual, "HangZhou,Boston") + require.NoError(t, err) + + ti, err := time.Parse(time.RFC3339, "1993-10-07T20:17:05Z") + require.NoError(t, err) + dv := &defaultValue{"Joe", 10, true, nil, 1.25, ti, []string{"HangZhou", "Boston"}} + assert.NoError(t, f.MapTo(dv)) + assert.Equal(t, "Joe", dv.Name) + assert.Equal(t, 10, dv.Age) + assert.True(t, dv.Male) + assert.Equal(t, 1.25, dv.Money) + assert.Equal(t, ti.String(), dv.Born.String()) + assert.Equal(t, "HangZhou,Boston", strings.Join(dv.Cities, ",")) }) - Convey("Map to extended base", func() { + t.Run("map to extended base", func(t *testing.T) { f, err := ini.Load([]byte(confDataStruct)) - So(err, ShouldBeNil) - So(f, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, f) te := testExtend{} - So(f.Section("extended").MapTo(&te), ShouldBeNil) - So(te.Base, ShouldBeTrue) - So(te.Extend, ShouldBeTrue) + assert.NoError(t, f.Section("extended").MapTo(&te)) + assert.True(t, te.Base) + assert.True(t, te.Extend) }) }) - Convey("Map to struct in strict mode", t, func() { + t.Run("map to struct in strict mode", func(t *testing.T) { f, err := ini.Load([]byte(` name=bruce age=a30`)) - So(err, ShouldBeNil) + require.NoError(t, err) type Strict struct { Name string `ini:"name"` @@ -369,76 +370,76 @@ age=a30`)) } s := new(Strict) - So(f.Section("").StrictMapTo(s), ShouldNotBeNil) + assert.Error(t, f.Section("").StrictMapTo(s)) }) - Convey("Map slice in strict mode", t, func() { + t.Run("map slice in strict mode", func(t *testing.T) { f, err := ini.Load([]byte(` names=alice, bruce`)) - So(err, ShouldBeNil) + require.NoError(t, err) type Strict struct { Names []string `ini:"names"` } s := new(Strict) - So(f.Section("").StrictMapTo(s), ShouldBeNil) - So(fmt.Sprint(s.Names), ShouldEqual, "[alice bruce]") + assert.NoError(t, f.Section("").StrictMapTo(s)) + assert.Equal(t, "[alice bruce]", fmt.Sprint(s.Names)) }) } func Test_MapToStructNonUniqueSections(t *testing.T) { - Convey("Map to struct non unique", t, func() { - Convey("Map file to struct non unique", func() { + t.Run("map to struct non unique", func(t *testing.T) { + t.Run("map file to struct non unique", func(t *testing.T) { f, err := ini.LoadSources(ini.LoadOptions{AllowNonUniqueSections: true}, []byte(confNonUniqueSectionDataStruct)) - So(err, ShouldBeNil) + require.NoError(t, err) ts := new(testNonUniqueSectionsStruct) - So(f.MapTo(ts), ShouldBeNil) + assert.NoError(t, f.MapTo(ts)) - So(ts.Interface.Address, ShouldEqual, "10.2.0.1/24") - So(ts.Interface.ListenPort, ShouldEqual, 34777) - So(ts.Interface.PrivateKey, ShouldEqual, "privServerKey") + assert.Equal(t, "10.2.0.1/24", ts.Interface.Address) + assert.Equal(t, 34777, ts.Interface.ListenPort) + assert.Equal(t, "privServerKey", ts.Interface.PrivateKey) - So(ts.Peer[0].PublicKey, ShouldEqual, "pubClientKey") - So(ts.Peer[0].PresharedKey, ShouldEqual, "psKey") - So(ts.Peer[0].AllowedIPs[0], ShouldEqual, "10.2.0.2/32") - So(ts.Peer[0].AllowedIPs[1], ShouldEqual, "fd00:2::2/128") + assert.Equal(t, "pubClientKey", ts.Peer[0].PublicKey) + assert.Equal(t, "psKey", ts.Peer[0].PresharedKey) + assert.Equal(t, "10.2.0.2/32", ts.Peer[0].AllowedIPs[0]) + assert.Equal(t, "fd00:2::2/128", ts.Peer[0].AllowedIPs[1]) - So(ts.Peer[1].PublicKey, ShouldEqual, "pubClientKey2") - So(ts.Peer[1].PresharedKey, ShouldEqual, "psKey2") - So(ts.Peer[1].AllowedIPs[0], ShouldEqual, "10.2.0.3/32") - So(ts.Peer[1].AllowedIPs[1], ShouldEqual, "fd00:2::3/128") + assert.Equal(t, "pubClientKey2", ts.Peer[1].PublicKey) + assert.Equal(t, "psKey2", ts.Peer[1].PresharedKey) + assert.Equal(t, "10.2.0.3/32", ts.Peer[1].AllowedIPs[0]) + assert.Equal(t, "fd00:2::3/128", ts.Peer[1].AllowedIPs[1]) }) - Convey("Map non unique section to struct", func() { + t.Run("map non unique section to struct", func(t *testing.T) { newPeer := new(testPeer) newPeerSlice := make([]testPeer, 0) f, err := ini.LoadSources(ini.LoadOptions{AllowNonUniqueSections: true}, []byte(confNonUniqueSectionDataStruct)) - So(err, ShouldBeNil) + require.NoError(t, err) // try only first one - So(f.Section("Peer").MapTo(newPeer), ShouldBeNil) - So(newPeer.PublicKey, ShouldEqual, "pubClientKey") - So(newPeer.PresharedKey, ShouldEqual, "psKey") - So(newPeer.AllowedIPs[0], ShouldEqual, "10.2.0.2/32") - So(newPeer.AllowedIPs[1], ShouldEqual, "fd00:2::2/128") + assert.NoError(t, f.Section("Peer").MapTo(newPeer)) + assert.Equal(t, "pubClientKey", newPeer.PublicKey) + assert.Equal(t, "psKey", newPeer.PresharedKey) + assert.Equal(t, "10.2.0.2/32", newPeer.AllowedIPs[0]) + assert.Equal(t, "fd00:2::2/128", newPeer.AllowedIPs[1]) // try all - So(f.Section("Peer").MapTo(&newPeerSlice), ShouldBeNil) - So(newPeerSlice[0].PublicKey, ShouldEqual, "pubClientKey") - So(newPeerSlice[0].PresharedKey, ShouldEqual, "psKey") - So(newPeerSlice[0].AllowedIPs[0], ShouldEqual, "10.2.0.2/32") - So(newPeerSlice[0].AllowedIPs[1], ShouldEqual, "fd00:2::2/128") - - So(newPeerSlice[1].PublicKey, ShouldEqual, "pubClientKey2") - So(newPeerSlice[1].PresharedKey, ShouldEqual, "psKey2") - So(newPeerSlice[1].AllowedIPs[0], ShouldEqual, "10.2.0.3/32") - So(newPeerSlice[1].AllowedIPs[1], ShouldEqual, "fd00:2::3/128") + assert.NoError(t, f.Section("Peer").MapTo(&newPeerSlice)) + assert.Equal(t, "pubClientKey", newPeerSlice[0].PublicKey) + assert.Equal(t, "psKey", newPeerSlice[0].PresharedKey) + assert.Equal(t, "10.2.0.2/32", newPeerSlice[0].AllowedIPs[0]) + assert.Equal(t, "fd00:2::2/128", newPeerSlice[0].AllowedIPs[1]) + + assert.Equal(t, "pubClientKey2", newPeerSlice[1].PublicKey) + assert.Equal(t, "psKey2", newPeerSlice[1].PresharedKey) + assert.Equal(t, "10.2.0.3/32", newPeerSlice[1].AllowedIPs[0]) + assert.Equal(t, "fd00:2::3/128", newPeerSlice[1].AllowedIPs[1]) }) - Convey("Map non unique sections with subsections to struct", func() { + t.Run("map non unique sections with subsections to struct", func(t *testing.T) { iniFile, err := ini.LoadSources(ini.LoadOptions{AllowNonUniqueSections: true}, strings.NewReader(` [Section] FieldInSubSection = 1 @@ -450,7 +451,7 @@ FieldInSubSection = 4 FieldInSubSection2 = 5 FieldInSection = 6 `)) - So(err, ShouldBeNil) + require.NoError(t, err) type SubSection struct { FieldInSubSection string `ini:"FieldInSubSection"` @@ -471,21 +472,21 @@ FieldInSection = 6 f := new(File) err = iniFile.MapTo(f) - So(err, ShouldBeNil) + require.NoError(t, err) - So(f.Sections[0].FieldInSubSection, ShouldEqual, "1") - So(f.Sections[0].FieldInSubSection2, ShouldEqual, "2") - So(f.Sections[0].FieldInSection, ShouldEqual, "3") + assert.Equal(t, "1", f.Sections[0].FieldInSubSection) + assert.Equal(t, "2", f.Sections[0].FieldInSubSection2) + assert.Equal(t, "3", f.Sections[0].FieldInSection) - So(f.Sections[1].FieldInSubSection, ShouldEqual, "4") - So(f.Sections[1].FieldInSubSection2, ShouldEqual, "5") - So(f.Sections[1].FieldInSection, ShouldEqual, "6") + assert.Equal(t, "4", f.Sections[1].FieldInSubSection) + assert.Equal(t, "5", f.Sections[1].FieldInSubSection2) + assert.Equal(t, "6", f.Sections[1].FieldInSection) }) }) } func Test_ReflectFromStruct(t *testing.T) { - Convey("Reflect from struct", t, func() { + t.Run("reflect from struct", func(t *testing.T) { type Embeded struct { Dates []time.Time `delim:"|" comment:"Time data"` Places []string @@ -510,11 +511,11 @@ func Test_ReflectFromStruct(t *testing.T) { *Embeded `ini:"infos" comment:"Embeded section"` } - t, err := time.Parse(time.RFC3339, "1993-10-07T20:17:05Z") - So(err, ShouldBeNil) - a := &Author{"Unknwon", true, nil, 21, 100, 2.8, t, "", "ignored", + ti, err := time.Parse(time.RFC3339, "1993-10-07T20:17:05Z") + require.NoError(t, err) + a := &Author{"Unknwon", true, nil, 21, 100, 2.8, ti, "", "ignored", &Embeded{ - []time.Time{t, t}, + []time.Time{ti, ti}, []string{"HangZhou", "Boston"}, []int{1993, 1994}, []int64{10010, 10086}, @@ -525,12 +526,12 @@ func Test_ReflectFromStruct(t *testing.T) { []int{}, }} cfg := ini.Empty() - So(ini.ReflectFrom(cfg, a), ShouldBeNil) + assert.NoError(t, ini.ReflectFrom(cfg, a)) var buf bytes.Buffer _, err = cfg.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `NAME = Unknwon + require.NoError(t, err) + assert.Equal(t, `NAME = Unknwon Male = true Optional = ; Author's age @@ -552,13 +553,15 @@ Coordinates = 192.168,10.11 Flags = true,false None = -`) +`, + buf.String(), + ) - Convey("Reflect from non-point struct", func() { - So(ini.ReflectFrom(cfg, Author{}), ShouldNotBeNil) + t.Run("reflect from non-point struct", func(t *testing.T) { + assert.Error(t, ini.ReflectFrom(cfg, Author{})) }) - Convey("Reflect from struct with omitempty", func() { + t.Run("reflect from struct with omitempty", func(t *testing.T) { cfg := ini.Empty() type SpecialStruct struct { FirstName string `ini:"first_name"` @@ -580,18 +583,20 @@ None = NotEmpty: 9, } - So(ini.ReflectFrom(cfg, special), ShouldBeNil) + assert.NoError(t, ini.ReflectFrom(cfg, special)) var buf bytes.Buffer _, err = cfg.WriteTo(&buf) - So(buf.String(), ShouldEqual, `first_name = John + assert.Equal(t, `first_name = John last_name = Doe omitempty = 9 -`) +`, + buf.String(), + ) }) - Convey("Reflect from struct with non-anonymous structure pointer", func() { + t.Run("reflect from struct with non-anonymous structure pointer", func(t *testing.T) { cfg := ini.Empty() type Rpc struct { Enable bool `ini:"enable"` @@ -611,23 +616,25 @@ omitempty = 9 Name: "name", }, } - So(cfg.ReflectFrom(config), ShouldBeNil) + assert.NoError(t, cfg.ReflectFrom(config)) var buf bytes.Buffer _, err = cfg.WriteTo(&buf) - So(buf.String(), ShouldEqual, `[rpc] + assert.Equal(t, `[rpc] enable = true type = type addr = address name = name -`) +`, + buf.String(), + ) }) }) } func Test_ReflectFromStructNonUniqueSections(t *testing.T) { - Convey("Reflect from struct with non unique sections", t, func() { + t.Run("reflect from struct with non unique sections", func(t *testing.T) { nonUnique := &testNonUniqueSectionsStruct{ Interface: testInterface{ Address: "10.2.0.1/24", @@ -652,12 +659,12 @@ func Test_ReflectFromStructNonUniqueSections(t *testing.T) { AllowNonUniqueSections: true, }) - So(ini.ReflectFrom(cfg, nonUnique), ShouldBeNil) + assert.NoError(t, ini.ReflectFrom(cfg, nonUnique)) var buf bytes.Buffer _, err := cfg.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, confNonUniqueSectionDataStruct) + require.NoError(t, err) + assert.Equal(t, confNonUniqueSectionDataStruct, buf.String()) // note: using ReflectFrom from should overwrite the existing sections err = cfg.Section("Peer").ReflectFrom([]*testPeer{ @@ -673,12 +680,12 @@ func Test_ReflectFromStructNonUniqueSections(t *testing.T) { }, }) - So(err, ShouldBeNil) + require.NoError(t, err) buf = bytes.Buffer{} _, err = cfg.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[Interface] + require.NoError(t, err) + assert.Equal(t, `[Interface] Address = 10.2.0.1/24 ListenPort = 34777 PrivateKey = privServerKey @@ -693,7 +700,9 @@ PublicKey = pubClientKey4 PresharedKey = psKey4 AllowedIPs = 10.2.0.5/32,fd00:2::5/128 -`) +`, + buf.String(), + ) // note: using ReflectFrom from should overwrite the existing sections err = cfg.Section("Peer").ReflectFrom(&testPeer{ @@ -702,12 +711,12 @@ AllowedIPs = 10.2.0.5/32,fd00:2::5/128 AllowedIPs: []string{"10.2.0.6/32,fd00:2::6/128"}, }) - So(err, ShouldBeNil) + require.NoError(t, err) buf = bytes.Buffer{} _, err = cfg.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[Interface] + require.NoError(t, err) + assert.Equal(t, `[Interface] Address = 10.2.0.1/24 ListenPort = 34777 PrivateKey = privServerKey @@ -717,13 +726,15 @@ PublicKey = pubClientKey5 PresharedKey = psKey5 AllowedIPs = 10.2.0.6/32,fd00:2::6/128 -`) +`, + buf.String(), + ) }) } // Inspired by https://github.com/go-ini/ini/issues/196 func TestMapToAndReflectFromStructWithShadows(t *testing.T) { - Convey("Map to struct and then reflect with shadows should generate original config content", t, func() { + t.Run("map to struct and then reflect with shadows should generate original config content", func(t *testing.T) { type include struct { Paths []string `ini:"path,omitempty,allowshadow"` } @@ -734,26 +745,28 @@ func TestMapToAndReflectFromStructWithShadows(t *testing.T) { [include] path = /tmp/gpm-profiles/test5.profile path = /tmp/gpm-profiles/test1.profile`)) - So(err, ShouldBeNil) + require.NoError(t, err) sec := cfg.Section("include") inc := new(include) err = sec.MapTo(inc) - So(err, ShouldBeNil) + require.NoError(t, err) err = sec.ReflectFrom(inc) - So(err, ShouldBeNil) + require.NoError(t, err) var buf bytes.Buffer _, err = cfg.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `[include] + require.NoError(t, err) + assert.Equal(t, `[include] path = /tmp/gpm-profiles/test5.profile path = /tmp/gpm-profiles/test1.profile -`) +`, + buf.String(), + ) - Convey("Reflect from struct with shadows", func() { + t.Run("reflect from struct with shadows", func(t *testing.T) { cfg := ini.Empty(ini.LoadOptions{ AllowShadows: true, }) @@ -787,12 +800,12 @@ path = /tmp/gpm-profiles/test1.profile None: []int{}, } - So(ini.ReflectFrom(cfg, shadow), ShouldBeNil) + assert.NoError(t, ini.ReflectFrom(cfg, shadow)) var buf bytes.Buffer _, err := cfg.WriteTo(&buf) - So(err, ShouldBeNil) - So(buf.String(), ShouldEqual, `sa = s1 + require.NoError(t, err) + assert.Equal(t, `sa = s1 sa = s2 allowshadow = s3 allowshadow = s4 @@ -813,7 +826,9 @@ Flags = true Flags = false None = -`) +`, + buf.String(), + ) }) }) } @@ -823,17 +838,17 @@ type testMapper struct { } func Test_NameGetter(t *testing.T) { - Convey("Test name mappers", t, func() { - So(ini.MapToWithMapper(&testMapper{}, ini.TitleUnderscore, []byte("packag_name=ini")), ShouldBeNil) + t.Run("test name mappers", func(t *testing.T) { + assert.NoError(t, ini.MapToWithMapper(&testMapper{}, ini.TitleUnderscore, []byte("packag_name=ini"))) cfg, err := ini.Load([]byte("PACKAGE_NAME=ini")) - So(err, ShouldBeNil) - So(cfg, ShouldNotBeNil) + require.NoError(t, err) + require.NotNil(t, cfg) cfg.NameMapper = ini.SnackCase tg := new(testMapper) - So(cfg.MapTo(tg), ShouldBeNil) - So(tg.PackageName, ShouldEqual, "ini") + assert.NoError(t, cfg.MapTo(tg)) + assert.Equal(t, "ini", tg.PackageName) }) } @@ -842,13 +857,13 @@ type testDurationStruct struct { } func Test_Duration(t *testing.T) { - Convey("Duration less than 16m50s", t, func() { + t.Run("duration less than 16m50s", func(t *testing.T) { ds := new(testDurationStruct) - So(ini.MapTo(ds, []byte("Duration=16m49s")), ShouldBeNil) + assert.NoError(t, ini.MapTo(ds, []byte("Duration=16m49s"))) dur, err := time.ParseDuration("16m49s") - So(err, ShouldBeNil) - So(ds.Duration.Seconds(), ShouldEqual, dur.Seconds()) + require.NoError(t, err) + assert.Equal(t, dur.Seconds(), ds.Duration.Seconds()) }) } @@ -868,7 +883,7 @@ func (es Employers) ReflectINIStruct(f *ini.File) error { // Inspired by https://github.com/go-ini/ini/issues/199 func Test_StructReflector(t *testing.T) { - Convey("Reflect with StructReflector interface", t, func() { + t.Run("reflect with StructReflector interface", func(t *testing.T) { p := &struct { FirstName string Employer Employers @@ -887,13 +902,13 @@ func Test_StructReflector(t *testing.T) { } f := ini.Empty() - So(f.ReflectFrom(p), ShouldBeNil) + assert.NoError(t, f.ReflectFrom(p)) var buf bytes.Buffer _, err := f.WriteTo(&buf) - So(err, ShouldBeNil) + require.NoError(t, err) - So(buf.String(), ShouldEqual, `FirstName = Andrew + assert.Equal(t, `FirstName = Andrew [Employer "VMware"] Title = Staff II Engineer @@ -901,6 +916,8 @@ Title = Staff II Engineer [Employer "EMC"] Title = Consultant Engineer -`) +`, + buf.String(), + ) }) }