diff --git a/doc/version-management.md b/VERSION-MANAGEMENT.md similarity index 100% rename from doc/version-management.md rename to VERSION-MANAGEMENT.md diff --git a/conf/bind_test.go b/conf/bind_test.go index 77306524..c3f9c4cb 100644 --- a/conf/bind_test.go +++ b/conf/bind_test.go @@ -72,8 +72,8 @@ func TestConverter(t *testing.T) { t.Run("success", func(t *testing.T) { err := conf.New().Bind(&s) assert.Nil(t, err) - assert.Equal(t, s.Time, time.Date(2025, 2, 1, 0, 0, 0, 0, time.UTC)) - assert.Equal(t, s.Duration, 10*time.Second) + assert.That(t, s.Time).Equal(time.Date(2025, 2, 1, 0, 0, 0, 0, time.UTC)) + assert.That(t, s.Duration).Equal(10 * time.Second) }) t.Run("error", func(t *testing.T) { @@ -81,7 +81,7 @@ func TestConverter(t *testing.T) { "time": "2025-02-01M00:00:00", }) err := p.Bind(&s) - assert.Error(t, err, "unable to parse date: 2025-02-01M00:00:00") + assert.ThatError(t, err).Matches("unable to parse date: 2025-02-01M00:00:00") }) } @@ -91,19 +91,19 @@ func TestSplitter(t *testing.T) { var points []image.Point err := conf.New().Bind(&points, "${:=(1,2)(3,4)}>>PointSplitter") assert.Nil(t, err) - assert.Equal(t, points, []image.Point{{X: 1, Y: 2}, {X: 3, Y: 4}}) + assert.That(t, points).Equal([]image.Point{{X: 1, Y: 2}, {X: 3, Y: 4}}) }) t.Run("split error", func(t *testing.T) { var points []image.Point err := conf.New().Bind(&points, "${:=(1}>>PointSplitter") - assert.Error(t, err, "split error") + assert.ThatError(t, err).Matches("split error") }) t.Run("unknown splitter", func(t *testing.T) { var points []image.Point err := conf.New().Bind(&points, "${:=(1}>>UnknownSplitter") - assert.Error(t, err, "unknown splitter 'UnknownSplitter'") + assert.ThatError(t, err).Matches("unknown splitter 'UnknownSplitter'") }) } @@ -112,34 +112,34 @@ func TestParseTag(t *testing.T) { t.Run("normal", func(t *testing.T) { tag, err := conf.ParseTag("${a}") assert.Nil(t, err) - assert.Equal(t, tag.String(), "${a}") + assert.That(t, tag.String()).Equal("${a}") }) t.Run("default", func(t *testing.T) { tag, err := conf.ParseTag("${a:=123}") assert.Nil(t, err) - assert.Equal(t, tag.String(), "${a:=123}") + assert.That(t, tag.String()).Equal("${a:=123}") }) t.Run("splitter", func(t *testing.T) { tag, err := conf.ParseTag("${a:=1,2,3}>>splitter") assert.Nil(t, err) - assert.Equal(t, tag.String(), "${a:=1,2,3}>>splitter") + assert.That(t, tag.String()).Equal("${a:=1,2,3}>>splitter") }) t.Run("error - 1", func(t *testing.T) { _, err := conf.ParseTag(">>splitter") - assert.Error(t, err, "parse tag .* error: invalid syntax") + assert.ThatError(t, err).Matches("parse tag .* error: invalid syntax") }) t.Run("error - 2", func(t *testing.T) { _, err := conf.ParseTag("${a:=1,2,3") - assert.Error(t, err, "parse tag .* error: invalid syntax") + assert.ThatError(t, err).Matches("parse tag .* error: invalid syntax") }) t.Run("error - 3", func(t *testing.T) { _, err := conf.ParseTag("{a:=1,2,3}") - assert.Error(t, err, "parse tag .* error: invalid syntax") + assert.ThatError(t, err).Matches("parse tag .* error: invalid syntax") }) } @@ -149,14 +149,14 @@ func TestBindParam(t *testing.T) { var param conf.BindParam err := param.BindTag("${ROOT}", "") assert.Nil(t, err) - assert.Equal(t, param, conf.BindParam{}) + assert.That(t, param).Equal(conf.BindParam{}) }) t.Run("normal", func(t *testing.T) { var param conf.BindParam err := param.BindTag("${a:=1,2,3}>>splitter", "") assert.Nil(t, err) - assert.Equal(t, param, conf.BindParam{ + assert.That(t, param).Equal(conf.BindParam{ Key: "a", Path: "", Tag: conf.ParsedTag{ @@ -176,7 +176,7 @@ func TestBindParam(t *testing.T) { } err := param.BindTag("${a:=1,2,3}>>splitter", "") assert.Nil(t, err) - assert.Equal(t, param, conf.BindParam{ + assert.That(t, param).Equal(conf.BindParam{ Key: "s.a", Path: "Struct", Tag: conf.ParsedTag{ @@ -193,7 +193,7 @@ func TestBindParam(t *testing.T) { var param conf.BindParam err := param.BindTag("${:=1,2,3}>>splitter", "") assert.Nil(t, err) - assert.Equal(t, param, conf.BindParam{ + assert.That(t, param).Equal(conf.BindParam{ Key: "", Path: "", Tag: conf.ParsedTag{ @@ -209,13 +209,13 @@ func TestBindParam(t *testing.T) { t.Run("error - 1", func(t *testing.T) { var param conf.BindParam err := param.BindTag("a:=123", "") - assert.Error(t, err, "parse tag .* error: invalid syntax") + assert.ThatError(t, err).Matches("parse tag .* error: invalid syntax") }) t.Run("error - 2", func(t *testing.T) { var param conf.BindParam err := param.BindTag("${}", "") - assert.Error(t, err, "parse tag .* error: invalid syntax") + assert.ThatError(t, err).Matches("parse tag .* error: invalid syntax") }) } @@ -277,7 +277,7 @@ func TestProperties_Bind(t *testing.T) { var s UnnamedDefault err := conf.New().Bind(&s) assert.Nil(t, err) - assert.Equal(t, s, UnnamedDefault{ + assert.That(t, s).Equal(UnnamedDefault{ Strs: []string{"1", "2", "3"}, Ints: []int{}, Map: map[string]int{}, @@ -287,17 +287,17 @@ func TestProperties_Bind(t *testing.T) { t.Run("BindTag error", func(t *testing.T) { var i int err := conf.New().Bind(&i, "$") - assert.Error(t, err, "parse tag '\\$' error: invalid syntax") + assert.ThatError(t, err).Matches("parse tag '\\$' error: invalid syntax") }) t.Run("target error - 1", func(t *testing.T) { err := conf.New().Bind(5) - assert.Error(t, err, "should be a ptr") + assert.ThatError(t, err).Matches("should be a ptr") }) t.Run("target error - 1", func(t *testing.T) { err := conf.New().Bind(new(*int)) - assert.Error(t, err, "target should be value type") + assert.ThatError(t, err).Matches("target should be value type") }) t.Run("validate error", func(t *testing.T) { @@ -307,14 +307,14 @@ func TestProperties_Bind(t *testing.T) { err := conf.Map(map[string]interface{}{ "v": "1", }).Bind(&s) - assert.Error(t, err, "validate failed on .* for value 1") + assert.ThatError(t, err).Matches("validate failed on .* for value 1") }) t.Run("array error", func(t *testing.T) { err := conf.New().Bind(new(struct { Arr [3]string `value:"${arr:=1,2,3}"` })) - assert.Error(t, err, "use slice instead of array") + assert.ThatError(t, err).Matches("use slice instead of array") }) t.Run("type error - 1", func(t *testing.T) { @@ -324,7 +324,7 @@ func TestProperties_Bind(t *testing.T) { err := conf.Map(map[string]interface{}{ "v": "abc", }).Bind(&s) - assert.Error(t, err, "strconv.ParseInt: parsing .*: invalid syntax") + assert.ThatError(t, err).Matches("strconv.ParseInt: parsing .*: invalid syntax") }) t.Run("type error - 2", func(t *testing.T) { @@ -334,7 +334,7 @@ func TestProperties_Bind(t *testing.T) { err := conf.Map(map[string]interface{}{ "v": "abc", }).Bind(&s) - assert.Error(t, err, "strconv.ParseUint: parsing .*: invalid syntax") + assert.ThatError(t, err).Matches("strconv.ParseUint: parsing .*: invalid syntax") }) t.Run("type error - 3", func(t *testing.T) { @@ -344,7 +344,7 @@ func TestProperties_Bind(t *testing.T) { err := conf.Map(map[string]interface{}{ "v": "abc", }).Bind(&s) - assert.Error(t, err, "strconv.ParseFloat: parsing .*: invalid syntax") + assert.ThatError(t, err).Matches("strconv.ParseFloat: parsing .*: invalid syntax") }) t.Run("type error - 4", func(t *testing.T) { @@ -354,7 +354,7 @@ func TestProperties_Bind(t *testing.T) { err := conf.Map(map[string]interface{}{ "v": "abc", }).Bind(&s) - assert.Error(t, err, "strconv.ParseBool: parsing .*: invalid syntax") + assert.ThatError(t, err).Matches("strconv.ParseBool: parsing .*: invalid syntax") }) t.Run("slice error - 1", func(t *testing.T) { @@ -366,7 +366,7 @@ func TestProperties_Bind(t *testing.T) { "1", "2", "a", }, }).Bind(&s) - assert.Error(t, err, "strconv.ParseInt: parsing .*: invalid syntax") + assert.ThatError(t, err).Matches("strconv.ParseInt: parsing .*: invalid syntax") }) t.Run("slice error - 2", func(t *testing.T) { @@ -374,7 +374,7 @@ func TestProperties_Bind(t *testing.T) { Value []int `value:"${v}"` } err := conf.New().Bind(&s) - assert.Error(t, err, "property \"v\" not exist") + assert.ThatError(t, err).Matches("property \"v\" not exist") }) t.Run("slice error - 3", func(t *testing.T) { @@ -382,7 +382,7 @@ func TestProperties_Bind(t *testing.T) { Value []image.Rectangle `value:"${v:={(1,2)(3,4)}"` } err := conf.New().Bind(&s) - assert.Error(t, err, "can't find converter for image.Rectangle") + assert.ThatError(t, err).Matches("can't find converter for image.Rectangle") }) t.Run("map error - 1", func(t *testing.T) { @@ -390,7 +390,7 @@ func TestProperties_Bind(t *testing.T) { Value map[string]int `value:"${v:=a:b,1:2}"` } err := conf.New().Bind(&s) - assert.Error(t, err, "map can't have a non-empty default value") + assert.ThatError(t, err).Matches("map can't have a non-empty default value") }) t.Run("map error - 2", func(t *testing.T) { @@ -402,7 +402,7 @@ func TestProperties_Bind(t *testing.T) { "1", "2", "3", }, }).Bind(&s) - assert.Error(t, err, "property v.0 not exist") + assert.ThatError(t, err).Matches("property v.0 not exist") }) t.Run("map error - 3", func(t *testing.T) { @@ -412,7 +412,7 @@ func TestProperties_Bind(t *testing.T) { err := conf.Map(map[string]interface{}{ "v": "a:b,1:2", }).Bind(&s) - assert.Error(t, err, "property conflict at path v") + assert.ThatError(t, err).Matches("property conflict at path v") }) t.Run("map error - 4", func(t *testing.T) { @@ -420,7 +420,7 @@ func TestProperties_Bind(t *testing.T) { Value map[string]int `value:"${v}"` } err := conf.New().Bind(&s) - assert.Error(t, err, "property \"v\" not exist") + assert.ThatError(t, err).Matches("property \"v\" not exist") }) t.Run("struct error - 1", func(t *testing.T) { @@ -430,7 +430,7 @@ func TestProperties_Bind(t *testing.T) { } `value:"${v:={123}}"` } err := conf.New().Bind(&s) - assert.Error(t, err, "struct can't have a non-empty default value") + assert.ThatError(t, err).Matches("struct can't have a non-empty default value") }) t.Run("struct error - 2", func(t *testing.T) { @@ -441,7 +441,7 @@ func TestProperties_Bind(t *testing.T) { "v": "123", }).Bind(&s) assert.Nil(t, err) - assert.Equal(t, s.int, 0) + assert.That(t, s.int).Equal(0) }) t.Run("struct error - 3", func(t *testing.T) { @@ -449,7 +449,7 @@ func TestProperties_Bind(t *testing.T) { Value int `value:"v"` } err := conf.New().Bind(&s) - assert.Error(t, err, "parse tag 'v' error: invalid syntax") + assert.ThatError(t, err).Matches("parse tag 'v' error: invalid syntax") }) t.Run("struct error - 4", func(t *testing.T) { @@ -465,7 +465,7 @@ func TestProperties_Bind(t *testing.T) { v := reflect.ValueOf(&i).Elem() err := conf.New().Bind(v, "${:=3}") assert.Nil(t, err) - assert.Equal(t, i, 3) + assert.That(t, i).Equal(3) }) t.Run("success", func(t *testing.T) { @@ -556,11 +556,11 @@ func TestProperties_Bind(t *testing.T) { var c DBConfig err = p.Bind(&c) assert.Nil(t, err) - assert.Equal(t, c, expect) + assert.That(t, c).Equal(expect) err = p.Bind(&c, "${prefix}") assert.Nil(t, err) - assert.Equal(t, c, expect) + assert.That(t, c).Equal(expect) }) t.Run("filter false", func(t *testing.T) { @@ -578,7 +578,7 @@ func TestProperties_Bind(t *testing.T) { return false, nil })) assert.Nil(t, err) - assert.Equal(t, s.Value, 3) + assert.That(t, s.Value).Equal(3) }) t.Run("filter true", func(t *testing.T) { @@ -596,7 +596,7 @@ func TestProperties_Bind(t *testing.T) { return true, nil })) assert.Nil(t, err) - assert.Equal(t, s.Value, 0) + assert.That(t, s.Value).Equal(0) }) t.Run("filter error", func(t *testing.T) { @@ -613,7 +613,7 @@ func TestProperties_Bind(t *testing.T) { funcFilter(func(i interface{}, param conf.BindParam) (bool, error) { return false, errors.New("filter error") })) - assert.Error(t, err, "filter error") - assert.Equal(t, s.Value, 0) + assert.ThatError(t, err).Matches("filter error") + assert.That(t, s.Value).Equal(0) }) } diff --git a/conf/conf_test.go b/conf/conf_test.go index 6e96cb77..7ba10904 100644 --- a/conf/conf_test.go +++ b/conf/conf_test.go @@ -30,7 +30,7 @@ func TestProperties_Load(t *testing.T) { t.Run("success", func(t *testing.T) { p, err := conf.Load("./testdata/config/app.properties") assert.Nil(t, err) - assert.Equal(t, p.Data(), map[string]string{ + assert.That(t, p.Data()).Equal(map[string]string{ "properties.list[0]": "1", "properties.list[1]": "2", "properties.obj.list[0].age": "4", @@ -42,17 +42,17 @@ func TestProperties_Load(t *testing.T) { t.Run("file not exist", func(t *testing.T) { _, err := conf.Load("./testdata/config/app.tcl") - assert.Error(t, err, "no such file or directory") + assert.ThatError(t, err).Matches("no such file or directory") }) t.Run("unsupported ext", func(t *testing.T) { _, err := conf.Load("./testdata/config/app.unknown") - assert.Error(t, err, "unsupported file type .unknown") + assert.ThatError(t, err).Matches("unsupported file type .unknown") }) t.Run("syntax error", func(t *testing.T) { _, err := conf.Load("./testdata/config/err.yaml") - assert.Error(t, err, "did not find expected node content") + assert.ThatError(t, err).Matches("did not find expected node content") }) } @@ -64,7 +64,7 @@ func TestProperties_Resolve(t *testing.T) { }) s, err := p.Resolve("${a.b.c[0]}") assert.Nil(t, err) - assert.Equal(t, s, "3") + assert.That(t, s).Equal("3") }) t.Run("success - 2", func(t *testing.T) { @@ -73,20 +73,20 @@ func TestProperties_Resolve(t *testing.T) { }) s, err := p.Resolve("${x:=${a.b.c[0]}}") assert.Nil(t, err) - assert.Equal(t, s, "3") + assert.That(t, s).Equal("3") }) t.Run("default", func(t *testing.T) { p := conf.New() s, err := p.Resolve("${a.b.c:=123}") assert.Nil(t, err) - assert.Equal(t, s, "123") + assert.That(t, s).Equal("123") }) t.Run("key not exist", func(t *testing.T) { p := conf.New() _, err := p.Resolve("${a.b.c}") - assert.Error(t, err, "property a.b.c not exist") + assert.ThatError(t, err).Matches("property a.b.c not exist") }) t.Run("syntax error - 1", func(t *testing.T) { @@ -94,7 +94,7 @@ func TestProperties_Resolve(t *testing.T) { "a.b.c": []string{"3"}, }) _, err := p.Resolve("${a.b.c}") - assert.Error(t, err, "property a.b.c isn't simple value") + assert.ThatError(t, err).Matches("property a.b.c isn't simple value") }) t.Run("syntax error - 2", func(t *testing.T) { @@ -102,7 +102,7 @@ func TestProperties_Resolve(t *testing.T) { "a.b.c": []string{"3"}, }) _, err := p.Resolve("${a.b.c") - assert.Error(t, err, "resolve string .* error: invalid syntax") + assert.ThatError(t, err).Matches("resolve string .* error: invalid syntax") }) t.Run("syntax error - 3", func(t *testing.T) { @@ -110,7 +110,7 @@ func TestProperties_Resolve(t *testing.T) { "a.b.c": []string{"3"}, }) _, err := p.Resolve("${a.b.c[0]}==${a.b.c}") - assert.Error(t, err, "property a.b.c isn't simple value") + assert.ThatError(t, err).Matches("property a.b.c isn't simple value") }) } @@ -120,21 +120,21 @@ func TestProperties_CopyTo(t *testing.T) { p := conf.Map(map[string]interface{}{ "a.b.c": []string{"3"}, }) - assert.Equal(t, p.Keys(), []string{ + assert.That(t, p.Keys()).Equal([]string{ "a.b.c[0]", }) assert.True(t, p.Has("a.b.c")) assert.True(t, p.Has("a.b.c[0]")) - assert.Equal(t, p.Get("a.b.c[0]"), "3") - assert.Equal(t, p.Data(), map[string]string{ + assert.That(t, p.Get("a.b.c[0]")).Equal("3") + assert.That(t, p.Data()).Equal(map[string]string{ "a.b.c[0]": "3", }) s := conf.Map(map[string]interface{}{ "a.b.c": []string{"4", "5"}, }) - assert.Equal(t, s.Keys(), []string{ + assert.That(t, s.Keys()).Equal([]string{ "a.b.c[0]", "a.b.c[1]", }) @@ -142,14 +142,14 @@ func TestProperties_CopyTo(t *testing.T) { assert.True(t, s.Has("a.b.c")) assert.True(t, s.Has("a.b.c[0]")) assert.True(t, s.Has("a.b.c[1]")) - assert.Equal(t, s.Data(), map[string]string{ + assert.That(t, s.Data()).Equal(map[string]string{ "a.b.c[0]": "4", "a.b.c[1]": "5", }) err := p.CopyTo(s) assert.Nil(t, err) - assert.Equal(t, s.Data(), map[string]string{ + assert.That(t, s.Data()).Equal(map[string]string{ "a.b.c[0]": "3", "a.b.c[1]": "5", }) @@ -159,17 +159,17 @@ func TestProperties_CopyTo(t *testing.T) { p := conf.Map(map[string]interface{}{ "a.b.c": []string{"3"}, }) - assert.Equal(t, p.Data(), map[string]string{ + assert.That(t, p.Data()).Equal(map[string]string{ "a.b.c[0]": "3", }) s := conf.Map(map[string]interface{}{ "a.b.c": "3", }) - assert.Equal(t, s.Get("a.b.c"), "3") + assert.That(t, s.Get("a.b.c")).Equal("3") err := p.CopyTo(s) - assert.Error(t, err, "property conflict at path a.b.c\\[0]") + assert.ThatError(t, err).Matches("property conflict at path a.b.c\\[0]") }) } diff --git a/conf/expr_test.go b/conf/expr_test.go index ad28f242..3737626d 100644 --- a/conf/expr_test.go +++ b/conf/expr_test.go @@ -37,7 +37,7 @@ func TestExpr(t *testing.T) { }) err := p.Bind(&v) assert.Nil(t, err) - assert.Equal(t, 4, v.A) + assert.That(t, 4).Equal(v.A) }) t.Run("return false", func(t *testing.T) { @@ -48,7 +48,7 @@ func TestExpr(t *testing.T) { "a": 14, }) err := p.Bind(&v) - assert.Error(t, err, "validate failed on .* for value 14") + assert.ThatError(t, err).Matches("validate failed on .* for value 14") }) t.Run("return not bool", func(t *testing.T) { @@ -59,6 +59,6 @@ func TestExpr(t *testing.T) { "a": 4, }) err := p.Bind(&v) - assert.Error(t, err, "eval .* doesn't return bool value") + assert.ThatError(t, err).Matches("eval .* doesn't return bool value") }) } diff --git a/conf/reader/json/json_test.go b/conf/reader/json/json_test.go index 4fbc5424..d44bd0d0 100644 --- a/conf/reader/json/json_test.go +++ b/conf/reader/json/json_test.go @@ -26,7 +26,7 @@ func TestRead(t *testing.T) { t.Run("error", func(t *testing.T) { _, err := Read([]byte(`{`)) - assert.Error(t, err, "unexpected end of JSON input") + assert.ThatError(t, err).Matches("unexpected end of JSON input") }) t.Run("basic type", func(t *testing.T) { @@ -40,7 +40,7 @@ func TestRead(t *testing.T) { "time": "2018-02-17T15:02:31+08:00" }`)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "empty": "", "bool": false, "int": float64(3), diff --git a/conf/reader/prop/prop_test.go b/conf/reader/prop/prop_test.go index 5c8ad33d..499e0f08 100644 --- a/conf/reader/prop/prop_test.go +++ b/conf/reader/prop/prop_test.go @@ -35,7 +35,7 @@ func TestRead(t *testing.T) { time=2018-02-17T15:02:31+08:00 `)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "empty": "", "bool": "false", "int": "3", @@ -54,7 +54,7 @@ func TestRead(t *testing.T) { map.string=hello `)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "map.bool": "false", "map.int": "3", "map.float": "3.0", @@ -74,7 +74,7 @@ func TestRead(t *testing.T) { array[1].string=hello `)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "array[0].bool": "false", "array[0].int": "3", "array[0].float": "3.0", @@ -99,7 +99,7 @@ func TestRead(t *testing.T) { map.k2.string=hello `)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "map.k1.bool": "false", "map.k1.int": "3", "map.k1.float": "3.0", diff --git a/conf/reader/toml/toml_test.go b/conf/reader/toml/toml_test.go index 788f53ed..978e99d9 100644 --- a/conf/reader/toml/toml_test.go +++ b/conf/reader/toml/toml_test.go @@ -26,7 +26,7 @@ func TestRead(t *testing.T) { t.Run("error", func(t *testing.T) { _, err := Read([]byte(`{`)) - assert.Error(t, err, "parsing error: keys cannot contain { character") + assert.ThatError(t, err).Matches("parsing error: keys cannot contain { character") }) t.Run("basic type", func(t *testing.T) { @@ -41,7 +41,7 @@ func TestRead(t *testing.T) { time="2018-02-17T15:02:31+08:00" `)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "empty": "", "bool": false, "int": int64(3), @@ -62,7 +62,7 @@ func TestRead(t *testing.T) { string="hello" `)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "map": map[string]interface{}{ "bool": false, "float": 3.0, @@ -87,7 +87,7 @@ func TestRead(t *testing.T) { string="hello" `)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "array": []interface{}{ map[string]interface{}{ "bool": false, @@ -120,7 +120,7 @@ func TestRead(t *testing.T) { string="hello" `)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "map": map[string]interface{}{ "k1": map[string]interface{}{ "bool": false, diff --git a/conf/reader/yaml/yaml_test.go b/conf/reader/yaml/yaml_test.go index 7bf9ae57..d7f9bb8e 100644 --- a/conf/reader/yaml/yaml_test.go +++ b/conf/reader/yaml/yaml_test.go @@ -27,7 +27,7 @@ func TestRead(t *testing.T) { t.Run("error", func(t *testing.T) { _, err := Read([]byte(`{`)) - assert.Error(t, err, "did not find expected node content") + assert.ThatError(t, err).Matches("did not find expected node content") }) t.Run("basic type", func(t *testing.T) { @@ -44,7 +44,7 @@ func TestRead(t *testing.T) { str = strings.ReplaceAll(str, "\t", " ") r, err := Read([]byte(str)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "empty": "", "bool": false, "int": 3, @@ -67,7 +67,7 @@ func TestRead(t *testing.T) { str = strings.ReplaceAll(str, "\t", " ") r, err := Read([]byte(str)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "map": map[interface{}]interface{}{ "bool": false, "float": 3.0, @@ -94,7 +94,7 @@ func TestRead(t *testing.T) { str = strings.ReplaceAll(str, "\t", " ") r, err := Read([]byte(str)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "array": []interface{}{ map[interface{}]interface{}{ "bool": false, @@ -129,7 +129,7 @@ func TestRead(t *testing.T) { str = strings.ReplaceAll(str, "\t", " ") r, err := Read([]byte(str)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "map": map[interface{}]interface{}{ "k1": map[interface{}]interface{}{ "bool": false, @@ -155,7 +155,7 @@ func TestRead(t *testing.T) { str = strings.ReplaceAll(str, "\t", " ") r, err := Read([]byte(str)) assert.Nil(t, err) - assert.Equal(t, r, map[string]interface{}{ + assert.That(t, r).Equal(map[string]interface{}{ "array": []interface{}{}, "map": map[interface{}]interface{}{}, }) diff --git a/conf/storage/path_test.go b/conf/storage/path_test.go index 9c11ba6e..5461da69 100644 --- a/conf/storage/path_test.go +++ b/conf/storage/path_test.go @@ -204,10 +204,10 @@ func TestSplitPath(t *testing.T) { for _, c := range testcases { p, err := SplitPath(c.Key) if err != nil { - assert.Equal(t, err, c.Err) + assert.That(t, err).Equal(c.Err) continue } - assert.Equal(t, p, c.Path, fmt.Sprintf("key=%s", c.Key)) - assert.Equal(t, JoinPath(p), c.Key) + assert.That(t, p).Equal(c.Path, fmt.Sprintf("key=%s", c.Key)) + assert.That(t, JoinPath(p)).Equal(c.Key) } } diff --git a/conf/storage/store_test.go b/conf/storage/store_test.go index b3066be2..d803b932 100644 --- a/conf/storage/store_test.go +++ b/conf/storage/store_test.go @@ -26,7 +26,7 @@ func TestStorage(t *testing.T) { t.Run("empty", func(t *testing.T) { s := NewStorage() - assert.Equal(t, s.RawData(), map[string]string{}) + assert.That(t, s.RawData()).Equal(map[string]string{}) subKeys, err := s.SubKeys("a") assert.Nil(t, err) @@ -45,7 +45,7 @@ func TestStorage(t *testing.T) { assert.False(t, s.Has("a[0]")) err = s.Set("", "abc") - assert.Error(t, err, "key is empty") + assert.ThatError(t, err).Matches("key is empty") }) t.Run("map-0", func(t *testing.T) { @@ -54,14 +54,14 @@ func TestStorage(t *testing.T) { err := s.Set("a", "b") assert.Nil(t, err) assert.True(t, s.Has("a")) - assert.Equal(t, s.RawData(), map[string]string{ + assert.That(t, s.RawData()).Equal(map[string]string{ "a": "b", }) err = s.Set("a.y", "x") - assert.Error(t, err, "property conflict at path a.y") + assert.ThatError(t, err).Matches("property conflict at path a.y") err = s.Set("a[0]", "x") - assert.Error(t, err, "property conflict at path a\\[0]") + assert.ThatError(t, err).Matches("property conflict at path a\\[0]") assert.False(t, s.Has("")) assert.False(t, s.Has("a[")) @@ -70,17 +70,17 @@ func TestStorage(t *testing.T) { subKeys, err := s.SubKeys("") assert.Nil(t, err) - assert.Equal(t, subKeys, []string{"a"}) + assert.That(t, subKeys).Equal([]string{"a"}) _, err = s.SubKeys("a") - assert.Error(t, err, "property conflict at path a") + assert.ThatError(t, err).Matches("property conflict at path a") _, err = s.SubKeys("a[") - assert.Error(t, err, "invalid key 'a\\['") + assert.ThatError(t, err).Matches("invalid key 'a\\['") err = s.Set("a", "c") assert.Nil(t, err) assert.True(t, s.Has("a")) - assert.Equal(t, s.RawData(), map[string]string{ + assert.That(t, s.RawData()).Equal(map[string]string{ "a": "c", }) }) @@ -92,7 +92,7 @@ func TestStorage(t *testing.T) { assert.Nil(t, err) assert.True(t, s.Has("m")) assert.True(t, s.Has("m.x")) - assert.Equal(t, s.RawData(), map[string]string{ + assert.That(t, s.RawData()).Equal(map[string]string{ "m.x": "y", }) @@ -103,28 +103,28 @@ func TestStorage(t *testing.T) { assert.False(t, s.Has("m.x[0]")) err = s.Set("m", "a") - assert.Error(t, err, "property conflict at path m") + assert.ThatError(t, err).Matches("property conflict at path m") err = s.Set("m.x.z", "w") - assert.Error(t, err, "property conflict at path m") + assert.ThatError(t, err).Matches("property conflict at path m") err = s.Set("m[0]", "f") - assert.Error(t, err, "property conflict at path m\\[0]") + assert.ThatError(t, err).Matches("property conflict at path m\\[0]") _, err = s.SubKeys("m.t") assert.Nil(t, err) subKeys, err := s.SubKeys("m") assert.Nil(t, err) - assert.Equal(t, subKeys, []string{"x"}) + assert.That(t, subKeys).Equal([]string{"x"}) _, err = s.SubKeys("m.x") - assert.Error(t, err, "property conflict at path m.x") + assert.ThatError(t, err).Matches("property conflict at path m.x") _, err = s.SubKeys("m[0]") - assert.Error(t, err, "property conflict at path m\\[0]") + assert.ThatError(t, err).Matches("property conflict at path m\\[0]") err = s.Set("m.x", "z") assert.Nil(t, err) assert.True(t, s.Has("m")) assert.True(t, s.Has("m.x")) - assert.Equal(t, s.RawData(), map[string]string{ + assert.That(t, s.RawData()).Equal(map[string]string{ "m.x": "z", }) @@ -133,14 +133,14 @@ func TestStorage(t *testing.T) { assert.True(t, s.Has("m")) assert.True(t, s.Has("m.x")) assert.True(t, s.Has("m.t")) - assert.Equal(t, s.RawData(), map[string]string{ + assert.That(t, s.RawData()).Equal(map[string]string{ "m.x": "z", "m.t": "q", }) subKeys, err = s.SubKeys("m") assert.Nil(t, err) - assert.Equal(t, subKeys, []string{"t", "x"}) + assert.That(t, subKeys).Equal([]string{"t", "x"}) }) t.Run("arr-0", func(t *testing.T) { @@ -149,36 +149,36 @@ func TestStorage(t *testing.T) { err := s.Set("[0]", "p") assert.Nil(t, err) assert.True(t, s.Has("[0]")) - assert.Equal(t, s.RawData(), map[string]string{ + assert.That(t, s.RawData()).Equal(map[string]string{ "[0]": "p", }) err = s.Set("[0]x", "f") - assert.Error(t, err, "invalid key '\\[0]x'") + assert.ThatError(t, err).Matches("invalid key '\\[0]x'") err = s.Set("[0].x", "f") - assert.Error(t, err, "property conflict at path \\[0].x") + assert.ThatError(t, err).Matches("property conflict at path \\[0].x") err = s.Set("[0]", "w") assert.Nil(t, err) - assert.Equal(t, s.RawData(), map[string]string{ + assert.That(t, s.RawData()).Equal(map[string]string{ "[0]": "w", }) subKeys, err := s.SubKeys("") assert.Nil(t, err) - assert.Equal(t, subKeys, []string{"0"}) + assert.That(t, subKeys).Equal([]string{"0"}) err = s.Set("[1]", "p") assert.Nil(t, err) assert.True(t, s.Has("[0]")) - assert.Equal(t, s.RawData(), map[string]string{ + assert.That(t, s.RawData()).Equal(map[string]string{ "[0]": "w", "[1]": "p", }) subKeys, err = s.SubKeys("") assert.Nil(t, err) - assert.Equal(t, subKeys, []string{"0", "1"}) + assert.That(t, subKeys).Equal([]string{"0", "1"}) }) t.Run("arr-1", func(t *testing.T) { @@ -188,7 +188,7 @@ func TestStorage(t *testing.T) { assert.Nil(t, err) assert.True(t, s.Has("s")) assert.True(t, s.Has("s[0]")) - assert.Equal(t, s.RawData(), map[string]string{ + assert.That(t, s.RawData()).Equal(map[string]string{ "s[0]": "p", }) @@ -197,19 +197,19 @@ func TestStorage(t *testing.T) { assert.True(t, s.Has("s")) assert.True(t, s.Has("s[0]")) assert.True(t, s.Has("s[1]")) - assert.Equal(t, s.RawData(), map[string]string{ + assert.That(t, s.RawData()).Equal(map[string]string{ "s[0]": "p", "s[1]": "o", }) subKeys, err := s.SubKeys("s") assert.Nil(t, err) - assert.Equal(t, subKeys, []string{"0", "1"}) + assert.That(t, subKeys).Equal([]string{"0", "1"}) err = s.Set("s", "w") - assert.Error(t, err, "property conflict at path s") + assert.ThatError(t, err).Matches("property conflict at path s") err = s.Set("s.x", "f") - assert.Error(t, err, "property conflict at path s.x") + assert.ThatError(t, err).Matches("property conflict at path s.x") }) t.Run("map && array", func(t *testing.T) { @@ -221,7 +221,7 @@ func TestStorage(t *testing.T) { assert.True(t, s.Has("a.b")) assert.True(t, s.Has("a.b[0]")) assert.True(t, s.Has("a.b[0].c")) - assert.Equal(t, s.RawData(), map[string]string{ + assert.That(t, s.RawData()).Equal(map[string]string{ "a.b[0].c": "123", }) @@ -232,7 +232,7 @@ func TestStorage(t *testing.T) { assert.True(t, s.Has("a.b[0]")) assert.True(t, s.Has("a.b[0].d")) assert.True(t, s.Has("a.b[0].d[0]")) - assert.Equal(t, s.RawData(), map[string]string{ + assert.That(t, s.RawData()).Equal(map[string]string{ "a.b[0].c": "123", "a.b[0].d[0]": "123", }) diff --git a/doc/.keep b/doc/.keep new file mode 100644 index 00000000..e69de29b diff --git a/go.mod b/go.mod index 7ce34762..2dfb9ff6 100644 --- a/go.mod +++ b/go.mod @@ -4,8 +4,9 @@ go 1.24 require ( github.com/expr-lang/expr v1.17.2 - github.com/lvan100/go-assert v0.0.1 - github.com/magiconair/properties v1.8.9 + github.com/lvan100/go-assert v0.0.2 + github.com/lvan100/go-loop v0.0.1 + github.com/magiconair/properties v1.8.10 github.com/pelletier/go-toml v1.9.5 github.com/spf13/cast v1.7.1 go.uber.org/mock v0.5.1 diff --git a/go.sum b/go.sum index b15b04a0..f9421519 100644 --- a/go.sum +++ b/go.sum @@ -8,10 +8,12 @@ github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/lvan100/go-assert v0.0.1 h1:qBYQ8zOvRl7u5+8YnTxKBaRnqYoADOS6XRyxecLFJnU= -github.com/lvan100/go-assert v0.0.1/go.mod h1:osFFuU9zt4/SdTaJ9uU3y9qabAFDYlaH4Yte/ndDAj4= -github.com/magiconair/properties v1.8.9 h1:nWcCbLq1N2v/cpNsy5WvQ37Fb+YElfq20WJ/a8RkpQM= -github.com/magiconair/properties v1.8.9/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= +github.com/lvan100/go-assert v0.0.2 h1:K1G++zfdM5h+1Q/hSctEEqqcJIOs327k2kLiO3MmE5E= +github.com/lvan100/go-assert v0.0.2/go.mod h1:osFFuU9zt4/SdTaJ9uU3y9qabAFDYlaH4Yte/ndDAj4= +github.com/lvan100/go-loop v0.0.1 h1:LIhKHpihBbUoT9wzIV3MqdntUPU0O7Sx7rJJWEkxBG0= +github.com/lvan100/go-loop v0.0.1/go.mod h1:/CEXgcoXzKdf9MBHyTM2PsEcWiB5gG564gS7AHnNLUA= +github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE= +github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8= github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= diff --git a/gs/examples/bookman/main.go b/gs/examples/bookman/main.go index 0225d771..65f63731 100644 --- a/gs/examples/bookman/main.go +++ b/gs/examples/bookman/main.go @@ -27,8 +27,8 @@ import ( "time" "github.com/go-spring/spring-core/gs" - "github.com/go-spring/spring-core/util/iterutil" "github.com/go-spring/spring-core/util/syslog" + "github.com/lvan100/go-loop" _ "github.com/go-spring/spring-core/gs/examples/bookman/src/app" _ "github.com/go-spring/spring-core/gs/examples/bookman/src/biz" @@ -80,7 +80,7 @@ func main() { func runTest(ctx context.Context) error { time.Sleep(time.Millisecond * 500) - iterutil.Times(5, func(_ int) { + loop.Times(5, func(_ int) { url := "http://127.0.0.1:9090/books" resp, err := http.Get(url) if err != nil { diff --git a/gs/examples/bookman/src/biz/service/book_service/book_service_test.go b/gs/examples/bookman/src/biz/service/book_service/book_service_test.go index 6e619ed3..2acec850 100644 --- a/gs/examples/bookman/src/biz/service/book_service/book_service_test.go +++ b/gs/examples/bookman/src/biz/service/book_service/book_service_test.go @@ -54,7 +54,7 @@ func TestBookService(t *testing.T) { })) // Verify server address configuration - assert.Equal(t, x.SvrAddr, "0.0.0.0:9090") + assert.That(t, x.SvrAddr).Equal("0.0.0.0:9090") s, o := x.Service, x.BookDao assert.NotNil(t, o) @@ -62,8 +62,8 @@ func TestBookService(t *testing.T) { // Test listing books books, err := s.ListBooks() assert.Nil(t, err) - assert.Equal(t, len(books), 1) - assert.Equal(t, books[0].ISBN, "978-0132350884") + assert.That(t, len(books)).Equal(1) + assert.That(t, books[0].ISBN).Equal("978-0132350884") // Test saving a new book err = s.SaveBook(book_dao.Book{ @@ -77,15 +77,15 @@ func TestBookService(t *testing.T) { // Verify book was added successfully books, err = s.ListBooks() assert.Nil(t, err) - assert.Equal(t, len(books), 2) - assert.Equal(t, books[1].ISBN, "978-0262033848") - assert.Equal(t, books[1].Title, "Introduction to Algorithms") + assert.That(t, len(books)).Equal(2) + assert.That(t, books[1].ISBN).Equal("978-0262033848") + assert.That(t, books[1].Title).Equal("Introduction to Algorithms") // Test retrieving a book by ISBN book, err := s.GetBook("978-0132350884") assert.Nil(t, err) - assert.Equal(t, book.ISBN, "978-0132350884") - assert.Equal(t, book.Title, "Clean Code") + assert.That(t, book.ISBN).Equal("978-0132350884") + assert.That(t, book.Title).Equal("Clean Code") // Test deleting a book err = s.DeleteBook("978-0132350884") @@ -94,5 +94,5 @@ func TestBookService(t *testing.T) { // Verify book deletion books, err = s.ListBooks() assert.Nil(t, err) - assert.Equal(t, len(books), 1) + assert.That(t, len(books)).Equal(1) } diff --git a/gs/examples/bookman/src/dao/book_dao/book_dao_test.go b/gs/examples/bookman/src/dao/book_dao/book_dao_test.go index b763a1e8..eedf76eb 100644 --- a/gs/examples/bookman/src/dao/book_dao/book_dao_test.go +++ b/gs/examples/bookman/src/dao/book_dao/book_dao_test.go @@ -38,7 +38,7 @@ func TestBookDao(t *testing.T) { x := gstest.Wire(t, &struct { SvrAddr string `value:"${server.addr}"` }{}) - assert.Equal(t, x.SvrAddr, "0.0.0.0:9090") + assert.That(t, x.SvrAddr).Equal("0.0.0.0:9090") // Retrieve BookDao instance o := gstest.Get[*BookDao](t) @@ -47,9 +47,9 @@ func TestBookDao(t *testing.T) { // Test listing books books, err := o.ListBooks() assert.Nil(t, err) - assert.Equal(t, len(books), 1) - assert.Equal(t, books[0].ISBN, "978-0134190440") - assert.Equal(t, books[0].Title, "The Go Programming Language") + assert.That(t, len(books)).Equal(1) + assert.That(t, books[0].ISBN).Equal("978-0134190440") + assert.That(t, books[0].Title).Equal("The Go Programming Language") // Test saving a new book err = o.SaveBook(Book{ @@ -58,20 +58,20 @@ func TestBookDao(t *testing.T) { ISBN: "978-0132350884", Publisher: "Prentice Hall", }) - assert.Equal(t, err, nil) + assert.That(t, err).Equal(nil) // Verify book was added books, err = o.ListBooks() assert.Nil(t, err) - assert.Equal(t, len(books), 2) - assert.Equal(t, books[0].ISBN, "978-0132350884") - assert.Equal(t, books[0].Title, "Clean Code") + assert.That(t, len(books)).Equal(2) + assert.That(t, books[0].ISBN).Equal("978-0132350884") + assert.That(t, books[0].Title).Equal("Clean Code") // Test retrieving a book by ISBN book, err := o.GetBook("978-0132350884") assert.Nil(t, err) - assert.Equal(t, book.Title, "Clean Code") - assert.Equal(t, book.Publisher, "Prentice Hall") + assert.That(t, book.Title).Equal("Clean Code") + assert.That(t, book.Publisher).Equal("Prentice Hall") // Test deleting a book err = o.DeleteBook("978-0132350884") @@ -80,6 +80,6 @@ func TestBookDao(t *testing.T) { // Verify book was deleted books, err = o.ListBooks() assert.Nil(t, err) - assert.Equal(t, len(books), 1) - assert.Equal(t, books[0].ISBN, "978-0134190440") + assert.That(t, len(books)).Equal(1) + assert.That(t, books[0].ISBN).Equal("978-0134190440") } diff --git a/gs/examples/startup/main.go b/gs/examples/startup/main.go index 5bcaeb1f..12db166a 100644 --- a/gs/examples/startup/main.go +++ b/gs/examples/startup/main.go @@ -53,14 +53,14 @@ func (s *Service) Echo(w http.ResponseWriter, r *http.Request) { } func (s *Service) Refresh(w http.ResponseWriter, r *http.Request) { - _ = sysconf.Set("refresh-time", time.Now().Format(timeLayout)) + sysconf.Set("refresh-time", time.Now().Format(timeLayout)) _ = gs.RefreshProperties() _, _ = w.Write([]byte("OK!")) } func main() { - _ = sysconf.Set("start-time", time.Now().Format(timeLayout)) - _ = sysconf.Set("refresh-time", time.Now().Format(timeLayout)) + sysconf.Set("start-time", time.Now().Format(timeLayout)) + sysconf.Set("refresh-time", time.Now().Format(timeLayout)) // Start the Go-Spring application. If it fails, log the error. if err := gs.Run(); err != nil { diff --git a/gs/gstest/gstest.go b/gs/gstest/gstest.go index 912aead3..9ffc8046 100644 --- a/gs/gstest/gstest.go +++ b/gs/gstest/gstest.go @@ -14,6 +14,11 @@ * limitations under the License. */ +// Package gstest is a unit testing framework designed for dependency injection in go-spring. +// Unlike standard dependency injection, in unit testing mode, the framework gracefully ignores +// non-critical dependency injection failures by logging warnings instead of halting execution. +// This ensures seamless testing workflows when dealing with extensive dependencies, +// as only the specific dependencies under test need to be validated, while others remain non-blocking. package gstest import ( diff --git a/gs/gstest/gstest_test.go b/gs/gstest/gstest_test.go index c061f9ec..a19766dd 100644 --- a/gs/gstest/gstest_test.go +++ b/gs/gstest/gstest_test.go @@ -43,11 +43,11 @@ func TestMain(m *testing.M) { func TestGSTest(t *testing.T) { a := gstest.Get[*app.App](t) - assert.Equal(t, a.Name, "test") + assert.That(t, a.Name).Equal("test") s := gstest.Wire(t, new(struct { App *app.App `autowire:""` Service *biz.Service `autowire:""` })) - assert.Equal(t, s.App.Name, "test") - assert.Equal(t, s.Service.Hello("xyz"), "hello xyz") + assert.That(t, s.App.Name).Equal("test") + assert.That(t, s.Service.Hello("xyz")).Equal("hello xyz") } diff --git a/gs/internal/gs/gs_test.go b/gs/internal/gs/gs_test.go index f12c68c3..a640194b 100644 --- a/gs/internal/gs/gs_test.go +++ b/gs/internal/gs/gs_test.go @@ -38,17 +38,17 @@ func TestBeanSelector(t *testing.T) { t.Run("no name", func(t *testing.T) { s := BeanSelectorFor[io.Reader]() typ, name := s.TypeAndName() - assert.Equal(t, name, "") - assert.Equal(t, typ, reflect.TypeFor[io.Reader]()) - assert.Equal(t, fmt.Sprint(s), "{Type:io.Reader}") + assert.That(t, name).Equal("") + assert.That(t, typ).Equal(reflect.TypeFor[io.Reader]()) + assert.That(t, fmt.Sprint(s)).Equal("{Type:io.Reader}") }) t.Run("with name", func(t *testing.T) { s := BeanSelectorFor[io.Writer]("writer") typ, name := s.TypeAndName() - assert.Equal(t, name, "writer") - assert.Equal(t, typ, reflect.TypeFor[io.Writer]()) - assert.Equal(t, fmt.Sprint(s), "{Type:io.Writer,Name:writer}") + assert.That(t, name).Equal("writer") + assert.That(t, typ).Equal(reflect.TypeFor[io.Writer]()) + assert.That(t, fmt.Sprint(s)).Equal("{Type:io.Writer,Name:writer}") }) } diff --git a/gs/internal/gs_app/app_test.go b/gs/internal/gs_app/app_test.go index a6fb327f..cee35f0f 100644 --- a/gs/internal/gs_app/app_test.go +++ b/gs/internal/gs_app/app_test.go @@ -62,16 +62,16 @@ func TestApp(t *testing.T) { err := app.Run() assert.Nil(t, err) time.Sleep(50 * time.Millisecond) - assert.String(t, logBuf.String()).Contains("Received signal: interrupt") + assert.ThatString(t, logBuf.String()).Contains("Received signal: interrupt") }) t.Run("config refresh error", func(t *testing.T) { t.Cleanup(clean) - _ = sysconf.Set("a", "123") + sysconf.Set("a", "123") _ = os.Setenv("GS_A_B", "456") app := NewApp() err := app.Run() - assert.Error(t, err, "property conflict at path a.b") + assert.ThatError(t, err).Matches("property conflict at path a.b") }) t.Run("container refresh error", func(t *testing.T) { @@ -81,7 +81,7 @@ func TestApp(t *testing.T) { return nil, errors.New("fail to create bean") }) err := app.Run() - assert.Error(t, err, "fail to create bean") + assert.ThatError(t, err).Matches("fail to create bean") }) t.Run("runner return error", func(t *testing.T) { @@ -93,27 +93,27 @@ func TestApp(t *testing.T) { app := NewApp() app.C.Object(r).AsRunner() err := app.Run() - assert.Error(t, err, "runner return error") + assert.ThatError(t, err).Matches("runner return error") }) t.Run("disable jobs & servers", func(t *testing.T) { t.Cleanup(clean) - _ = sysconf.Set("spring.app.enable-jobs", "false") - _ = sysconf.Set("spring.app.enable-servers", "false") + sysconf.Set("spring.app.enable-jobs", "false") + sysconf.Set("spring.app.enable-servers", "false") app := NewApp() go func() { time.Sleep(50 * time.Millisecond) assert.False(t, app.EnableJobs) assert.False(t, app.EnableServers) - assert.Equal(t, len(app.Jobs), 0) - assert.Equal(t, len(app.Servers), 0) - assert.Equal(t, len(app.Runners), 0) + assert.That(t, len(app.Jobs)).Equal(0) + assert.That(t, len(app.Servers)).Equal(0) + assert.That(t, len(app.Runners)).Equal(0) app.ShutDown() }() err := app.Run() assert.Nil(t, err) time.Sleep(50 * time.Millisecond) - assert.String(t, logBuf.String()).Contains("shutdown complete") + assert.ThatString(t, logBuf.String()).Contains("shutdown complete") }) t.Run("job return error", func(t *testing.T) { @@ -127,7 +127,7 @@ func TestApp(t *testing.T) { err := app.Run() assert.Nil(t, err) time.Sleep(50 * time.Millisecond) - assert.String(t, logBuf.String()).Contains("job run error: job return error") + assert.ThatString(t, logBuf.String()).Contains("job run error: job return error") }) t.Run("job panic", func(t *testing.T) { @@ -143,7 +143,7 @@ func TestApp(t *testing.T) { err := app.Run() assert.Nil(t, err) time.Sleep(50 * time.Millisecond) - assert.String(t, logBuf.String()).Contains("panic: job panic") + assert.ThatString(t, logBuf.String()).Contains("panic: job panic") }) t.Run("server return error", func(t *testing.T) { @@ -158,7 +158,7 @@ func TestApp(t *testing.T) { err := app.Run() assert.Nil(t, err) time.Sleep(50 * time.Millisecond) - assert.String(t, logBuf.String()).Contains("server serve error: server return error") + assert.ThatString(t, logBuf.String()).Contains("server serve error: server return error") }) t.Run("server panic", func(t *testing.T) { @@ -175,7 +175,7 @@ func TestApp(t *testing.T) { err := app.Run() assert.Nil(t, err) time.Sleep(50 * time.Millisecond) - assert.String(t, logBuf.String()).Contains("panic: server panic") + assert.ThatString(t, logBuf.String()).Contains("panic: server panic") }) t.Run("success", func(t *testing.T) { @@ -235,24 +235,24 @@ func TestApp(t *testing.T) { } go func() { time.Sleep(50 * time.Millisecond) - assert.Equal(t, app.ShutDownTimeout, time.Second*15) + assert.That(t, app.ShutDownTimeout).Equal(time.Second * 15) assert.True(t, app.EnableJobs) assert.True(t, app.EnableServers) - assert.Equal(t, len(app.Jobs), 2) - assert.Equal(t, len(app.Servers), 2) - assert.Equal(t, len(app.Runners), 2) + assert.That(t, len(app.Jobs)).Equal(2) + assert.That(t, len(app.Servers)).Equal(2) + assert.That(t, len(app.Runners)).Equal(2) app.ShutDown() }() err := app.Run() assert.Nil(t, err) time.Sleep(50 * time.Millisecond) <-j2Wait - assert.String(t, logBuf.String()).Contains("shutdown complete") + assert.ThatString(t, logBuf.String()).Contains("shutdown complete") }) t.Run("shutdown timeout", func(t *testing.T) { t.Cleanup(clean) - _ = sysconf.Set("spring.app.shutdown-timeout", "10ms") + sysconf.Set("spring.app.shutdown-timeout", "10ms") ctrl := gomock.NewController(t) defer ctrl.Finish() app := NewApp() @@ -273,7 +273,7 @@ func TestApp(t *testing.T) { err := app.Run() assert.Nil(t, err) time.Sleep(50 * time.Millisecond) - assert.String(t, logBuf.String()).Contains("shutdown timeout") + assert.ThatString(t, logBuf.String()).Contains("shutdown timeout") }) t.Run("shutdown error", func(t *testing.T) { @@ -297,6 +297,6 @@ func TestApp(t *testing.T) { err := app.Run() assert.Nil(t, err) time.Sleep(50 * time.Millisecond) - assert.String(t, logBuf.String()).Contains("shutdown server failed: server shutdown error") + assert.ThatString(t, logBuf.String()).Contains("shutdown server failed: server shutdown error") }) } diff --git a/gs/internal/gs_app/boot_test.go b/gs/internal/gs_app/boot_test.go index a73c19a2..97737033 100644 --- a/gs/internal/gs_app/boot_test.go +++ b/gs/internal/gs_app/boot_test.go @@ -32,7 +32,7 @@ func TestBoot(t *testing.T) { t.Run("flag is false", func(t *testing.T) { t.Cleanup(clean) - _ = sysconf.Set("a", "123") + sysconf.Set("a", "123") _ = os.Setenv("GS_A_B", "456") boot := NewBoot().(*BootImpl) err := boot.Run() @@ -41,12 +41,12 @@ func TestBoot(t *testing.T) { t.Run("config refresh error", func(t *testing.T) { t.Cleanup(clean) - _ = sysconf.Set("a", "123") + sysconf.Set("a", "123") _ = os.Setenv("GS_A_B", "456") boot := NewBoot().(*BootImpl) boot.Object(bytes.NewBuffer(nil)) err := boot.Run() - assert.Error(t, err, "property conflict at path a.b") + assert.ThatError(t, err).Matches("property conflict at path a.b") }) t.Run("container refresh error", func(t *testing.T) { @@ -56,7 +56,7 @@ func TestBoot(t *testing.T) { return nil, errors.New("fail to create bean") }) err := boot.Run() - assert.Error(t, err, "fail to create bean") + assert.ThatError(t, err).Matches("fail to create bean") }) t.Run("runner return error", func(t *testing.T) { @@ -66,7 +66,7 @@ func TestBoot(t *testing.T) { return errors.New("runner return error") }) err := boot.Run() - assert.Error(t, err, "runner return error") + assert.ThatError(t, err).Matches("runner return error") }) t.Run("success", func(t *testing.T) { diff --git a/gs/internal/gs_arg/arg_test.go b/gs/internal/gs_arg/arg_test.go index 07a66a75..2a8dd25b 100644 --- a/gs/internal/gs_arg/arg_test.go +++ b/gs/internal/gs_arg/arg_test.go @@ -45,7 +45,7 @@ func TestTagArg(t *testing.T) { tag := Tag("${int:=3}") v, err := tag.GetArgValue(c, reflect.TypeFor[string]()) assert.Nil(t, err) - assert.Equal(t, v.String(), "3") + assert.That(t, v.String()).Equal("3") }) t.Run("bind error", func(t *testing.T) { @@ -58,7 +58,7 @@ func TestTagArg(t *testing.T) { }) tag := Tag("${int:=3}") _, err := tag.GetArgValue(c, reflect.TypeFor[string]()) - assert.Error(t, err, "GetArgValue error << bind error") + assert.ThatError(t, err).Matches("GetArgValue error << bind error") }) t.Run("wire success", func(t *testing.T) { @@ -73,7 +73,7 @@ func TestTagArg(t *testing.T) { tag := Tag("http-server") v, err := tag.GetArgValue(c, reflect.TypeFor[*http.Server]()) assert.Nil(t, err) - assert.Equal(t, v.Interface().(*http.Server).Addr, ":9090") + assert.That(t, v.Interface().(*http.Server).Addr).Equal(":9090") }) t.Run("wire error", func(t *testing.T) { @@ -86,13 +86,13 @@ func TestTagArg(t *testing.T) { }) tag := Tag("server") _, err := tag.GetArgValue(c, reflect.TypeFor[*bytes.Buffer]()) - assert.Error(t, err, "GetArgValue error << wire error") + assert.ThatError(t, err).Matches("GetArgValue error << wire error") }) t.Run("type error", func(t *testing.T) { tag := Tag("server") _, err := tag.GetArgValue(nil, reflect.TypeFor[*string]()) - assert.Error(t, err, "GetArgValue error << unsupported argument type: \\*string") + assert.ThatError(t, err).Matches("GetArgValue error << unsupported argument type: \\*string") }) } @@ -100,7 +100,7 @@ func TestValueArg(t *testing.T) { t.Run("index", func(t *testing.T) { arg := Index(0, Value(1)) - assert.Equal(t, arg.(IndexArg).Idx, 0) + assert.That(t, arg.(IndexArg).Idx).Equal(0) assert.Panic(t, func() { _, _ = arg.GetArgValue(nil, reflect.TypeFor[int]()) }, "unimplemented method") @@ -117,13 +117,13 @@ func TestValueArg(t *testing.T) { tag := Value(&http.Server{Addr: ":9090"}) v, err := tag.GetArgValue(nil, reflect.TypeFor[*http.Server]()) assert.Nil(t, err) - assert.Equal(t, v.Interface().(*http.Server).Addr, ":9090") + assert.That(t, v.Interface().(*http.Server).Addr).Equal(":9090") }) t.Run("type error", func(t *testing.T) { tag := Value(new(int)) _, err := tag.GetArgValue(nil, reflect.TypeFor[*http.Server]()) - assert.Error(t, err, "GetArgValue error << cannot assign type:\\*int to type:\\*http.Server") + assert.ThatError(t, err).Matches("GetArgValue error << cannot assign type:\\*int to type:\\*http.Server") }) } @@ -132,7 +132,7 @@ func TestArgList_New(t *testing.T) { t.Run("invalid function type", func(t *testing.T) { fnType := reflect.TypeFor[int]() _, err := NewArgList(fnType, nil) - assert.Error(t, err, "NewArgList error << invalid function type:int") + assert.ThatError(t, err).Matches("NewArgList error << invalid function type:int") }) t.Run("mixed index and non-index args", func(t *testing.T) { @@ -142,7 +142,7 @@ func TestArgList_New(t *testing.T) { Value("test"), } _, err := NewArgList(fnType, args) - assert.Error(t, err, "NewArgList error << arguments must be all indexed or non-indexed") + assert.ThatError(t, err).Matches("NewArgList error << arguments must be all indexed or non-indexed") }) t.Run("mixed non-index and index args", func(t *testing.T) { @@ -152,7 +152,7 @@ func TestArgList_New(t *testing.T) { Index(1, Value("test")), } _, err := NewArgList(fnType, args) - assert.Error(t, err, "NewArgList error << arguments must be all indexed or non-indexed") + assert.ThatError(t, err).Matches("NewArgList error << arguments must be all indexed or non-indexed") }) t.Run("invalid argument index - 1", func(t *testing.T) { @@ -161,7 +161,7 @@ func TestArgList_New(t *testing.T) { Index(-1, Value(1)), } _, err := NewArgList(fnType, args) - assert.Error(t, err, "NewArgList error << invalid argument index -1") + assert.ThatError(t, err).Matches("NewArgList error << invalid argument index -1") }) t.Run("invalid argument index - 2", func(t *testing.T) { @@ -170,7 +170,7 @@ func TestArgList_New(t *testing.T) { Index(2, Value(1)), } _, err := NewArgList(fnType, args) - assert.Error(t, err, "NewArgList error << invalid argument index 2") + assert.ThatError(t, err).Matches("NewArgList error << invalid argument index 2") }) t.Run("non-index args success", func(t *testing.T) { @@ -182,7 +182,7 @@ func TestArgList_New(t *testing.T) { argList, err := NewArgList(fnType, args) assert.Nil(t, err) assert.NotNil(t, argList) - assert.Equal(t, argList.args, []gs.Arg{ + assert.That(t, argList.args).Equal([]gs.Arg{ Value(1), Value("test"), }) @@ -197,7 +197,7 @@ func TestArgList_New(t *testing.T) { argList, err := NewArgList(fnType, args) assert.Nil(t, err) assert.NotNil(t, argList) - assert.Equal(t, argList.args, []gs.Arg{ + assert.That(t, argList.args).Equal([]gs.Arg{ Value(1), Value("test"), }) @@ -213,7 +213,7 @@ func TestArgList_New(t *testing.T) { argList, err := NewArgList(fnType, args) assert.Nil(t, err) assert.NotNil(t, argList) - assert.Equal(t, argList.args, []gs.Arg{ + assert.That(t, argList.args).Equal([]gs.Arg{ Value(1), Value("test1"), Value("test2"), @@ -230,7 +230,7 @@ func TestArgList_New(t *testing.T) { argList, err := NewArgList(fnType, args) assert.Nil(t, err) assert.NotNil(t, argList) - assert.Equal(t, argList.args, []gs.Arg{ + assert.That(t, argList.args).Equal([]gs.Arg{ Value(1), Value("test1"), Value("test2"), @@ -246,7 +246,7 @@ func TestArgList_New(t *testing.T) { argList, err := NewArgList(fnType, args) assert.Nil(t, err) assert.NotNil(t, argList) - assert.Equal(t, argList.args, []gs.Arg{ + assert.That(t, argList.args).Equal([]gs.Arg{ Tag(""), Value("test1"), Value("test2"), @@ -268,9 +268,9 @@ func TestArgList_Get(t *testing.T) { ctx := NewMockArgContext(nil) values, err := argList.get(ctx) assert.Nil(t, err) - assert.Equal(t, 2, len(values)) - assert.Equal(t, 1, values[0].Interface().(int)) - assert.Equal(t, "test", values[1].Interface().(string)) + assert.That(t, 2).Equal(len(values)) + assert.That(t, 1).Equal(values[0].Interface().(int)) + assert.That(t, "test").Equal(values[1].Interface().(string)) }) t.Run("success with variadic function", func(t *testing.T) { @@ -286,10 +286,10 @@ func TestArgList_Get(t *testing.T) { ctx := NewMockArgContext(nil) values, err := argList.get(ctx) assert.Nil(t, err) - assert.Equal(t, 3, len(values)) - assert.Equal(t, 1, values[0].Interface().(int)) - assert.Equal(t, "test1", values[1].Interface().(string)) - assert.Equal(t, "test2", values[2].Interface().(string)) + assert.That(t, 3).Equal(len(values)) + assert.That(t, 1).Equal(values[0].Interface().(int)) + assert.That(t, "test1").Equal(values[1].Interface().(string)) + assert.That(t, "test2").Equal(values[2].Interface().(string)) }) t.Run("error when getting arg value", func(t *testing.T) { @@ -303,7 +303,7 @@ func TestArgList_Get(t *testing.T) { ctx := NewMockArgContext(nil) _, err = argList.get(ctx) - assert.Error(t, err, "GetArgValue error << cannot assign type:int to type:string") + assert.ThatError(t, err).Matches("GetArgValue error << cannot assign type:int to type:string") }) } @@ -316,7 +316,7 @@ func TestCallable_New(t *testing.T) { Value("test"), } _, err := NewCallable(fn, args) - assert.Error(t, err, "NewArgList error << invalid function type:string") + assert.ThatError(t, err).Matches("NewArgList error << invalid function type:string") }) t.Run("error in argument processing", func(t *testing.T) { @@ -332,7 +332,7 @@ func TestCallable_New(t *testing.T) { ctx := NewMockArgContext(nil) _, err = callable.Call(ctx) - assert.Error(t, err, "GetArgValue error << cannot assign type:int to type:string") + assert.ThatError(t, err).Matches("GetArgValue error << cannot assign type:int to type:string") }) } @@ -351,7 +351,7 @@ func TestCallable_Call(t *testing.T) { ctx := NewMockArgContext(nil) _, err = callable.Call(ctx) - assert.Error(t, err, "GetArgValue error << cannot assign type:int to type:string") + assert.ThatError(t, err).Matches("GetArgValue error << cannot assign type:int to type:string") }) t.Run("function return none", func(t *testing.T) { @@ -366,7 +366,7 @@ func TestCallable_Call(t *testing.T) { ctx := NewMockArgContext(nil) v, err := callable.Call(ctx) assert.Nil(t, err) - assert.Equal(t, len(v), 0) + assert.That(t, len(v)).Equal(0) }) t.Run("function return error", func(t *testing.T) { @@ -383,9 +383,9 @@ func TestCallable_Call(t *testing.T) { ctx := NewMockArgContext(nil) v, err := callable.Call(ctx) assert.Nil(t, err) - assert.Equal(t, 2, len(v)) - assert.Equal(t, "", v[0].Interface().(string)) - assert.Equal(t, "execution error", v[1].Interface().(error).Error()) + assert.That(t, 2).Equal(len(v)) + assert.That(t, "").Equal(v[0].Interface().(string)) + assert.That(t, "execution error").Equal(v[1].Interface().(error).Error()) }) t.Run("success - 1", func(t *testing.T) { @@ -402,8 +402,8 @@ func TestCallable_Call(t *testing.T) { ctx := NewMockArgContext(nil) v, err := callable.Call(ctx) assert.Nil(t, err) - assert.Equal(t, len(v), 2) - assert.Equal(t, "1-test", v[0].Interface().(string)) + assert.That(t, len(v)).Equal(2) + assert.That(t, "1-test").Equal(v[0].Interface().(string)) }) t.Run("success - 2", func(t *testing.T) { @@ -420,8 +420,8 @@ func TestCallable_Call(t *testing.T) { ctx := NewMockArgContext(nil) v, err := callable.Call(ctx) assert.Nil(t, err) - assert.Equal(t, len(v), 1) - assert.Equal(t, "1-test", v[0].Interface().(string)) + assert.That(t, len(v)).Equal(1) + assert.That(t, "1-test").Equal(v[0].Interface().(string)) }) t.Run("success with variadic function", func(t *testing.T) { @@ -439,8 +439,8 @@ func TestCallable_Call(t *testing.T) { ctx := NewMockArgContext(nil) v, err := callable.Call(ctx) assert.Nil(t, err) - assert.Equal(t, len(v), 1) - assert.Equal(t, "1-test1,test2", v[0].Interface().(string)) + assert.That(t, len(v)).Equal(1) + assert.That(t, "1-test1,test2").Equal(v[0].Interface().(string)) }) } @@ -493,7 +493,7 @@ func TestBindArg_Bind(t *testing.T) { Value("test"), } arg := Bind(fn, args...) - assert.Matches(t, arg.fileline, "gs/internal/gs_arg/arg_test.go:495") + assert.ThatString(t, arg.fileline).Matches("gs/internal/gs_arg/arg_test.go:495") }) t.Run("success - 2", func(t *testing.T) { @@ -505,7 +505,7 @@ func TestBindArg_Bind(t *testing.T) { Value("test"), } arg := Bind(fn, args...) - assert.Matches(t, arg.fileline, "gs/internal/gs_arg/arg_test.go:507") + assert.ThatString(t, arg.fileline).Matches("gs/internal/gs_arg/arg_test.go:507") }) } @@ -522,7 +522,7 @@ func TestBindArg_GetArgValue(t *testing.T) { arg := Bind(fn, args...) ctx := NewMockArgContext(nil) _, err := arg.GetArgValue(ctx, reflect.TypeFor[string]()) - assert.Error(t, err, "GetArgValue error << cannot assign type:int to type:string") + assert.ThatError(t, err).Matches("GetArgValue error << cannot assign type:int to type:string") }) t.Run("success", func(t *testing.T) { @@ -537,7 +537,7 @@ func TestBindArg_GetArgValue(t *testing.T) { ctx := NewMockArgContext(nil) v, err := arg.GetArgValue(ctx, reflect.TypeFor[string]()) assert.Nil(t, err) - assert.Equal(t, "1-test", v.Interface().(string)) + assert.That(t, "1-test").Equal(v.Interface().(string)) }) t.Run("error in function execution", func(t *testing.T) { @@ -551,7 +551,7 @@ func TestBindArg_GetArgValue(t *testing.T) { arg := Bind(fn, args...) ctx := NewMockArgContext(nil) _, err := arg.GetArgValue(ctx, reflect.TypeFor[string]()) - assert.Error(t, err, "execution error") + assert.ThatError(t, err).Matches("execution error") }) t.Run("no error in function execution", func(t *testing.T) { @@ -566,7 +566,7 @@ func TestBindArg_GetArgValue(t *testing.T) { ctx := NewMockArgContext(nil) v, err := arg.GetArgValue(ctx, reflect.TypeFor[string]()) assert.Nil(t, err) - assert.Equal(t, "1-test", v.Interface().(string)) + assert.That(t, "1-test").Equal(v.Interface().(string)) }) t.Run("success with variadic function", func(t *testing.T) { @@ -582,7 +582,7 @@ func TestBindArg_GetArgValue(t *testing.T) { ctx := NewMockArgContext(nil) v, err := arg.GetArgValue(ctx, reflect.TypeFor[string]()) assert.Nil(t, err) - assert.Equal(t, "1-test1,test2", v.Interface().(string)) + assert.That(t, "1-test1,test2").Equal(v.Interface().(string)) }) t.Run("error in condition", func(t *testing.T) { @@ -606,7 +606,7 @@ func TestBindArg_GetArgValue(t *testing.T) { return ok, err }) _, err := arg.GetArgValue(ctx, reflect.TypeFor[string]()) - assert.Error(t, err, "condition error") + assert.ThatError(t, err).Matches("condition error") }) t.Run("condition return false", func(t *testing.T) { @@ -656,6 +656,6 @@ func TestBindArg_GetArgValue(t *testing.T) { }) v, err := arg.GetArgValue(ctx, reflect.TypeFor[string]()) assert.Nil(t, err) - assert.Equal(t, "1-test", v.Interface().(string)) + assert.That(t, "1-test").Equal(v.Interface().(string)) }) } diff --git a/gs/internal/gs_bean/bean_test.go b/gs/internal/gs_bean/bean_test.go index fb578a44..2866683f 100644 --- a/gs/internal/gs_bean/bean_test.go +++ b/gs/internal/gs_bean/bean_test.go @@ -31,14 +31,14 @@ import ( ) func TestBeanStatus(t *testing.T) { - assert.Equal(t, BeanStatus(-2).String(), "unknown") - assert.Equal(t, StatusDeleted.String(), "deleted") - assert.Equal(t, StatusDefault.String(), "default") - assert.Equal(t, StatusResolving.String(), "resolving") - assert.Equal(t, StatusResolved.String(), "resolved") - assert.Equal(t, StatusCreating.String(), "creating") - assert.Equal(t, StatusCreated.String(), "created") - assert.Equal(t, StatusWired.String(), "wired") + assert.That(t, BeanStatus(-2).String()).Equal("unknown") + assert.That(t, StatusDeleted.String()).Equal("deleted") + assert.That(t, StatusDefault.String()).Equal("default") + assert.That(t, StatusResolving.String()).Equal("resolving") + assert.That(t, StatusResolved.String()).Equal("resolved") + assert.That(t, StatusCreating.String()).Equal("creating") + assert.That(t, StatusCreated.String()).Equal("created") + assert.That(t, StatusWired.String()).Equal("wired") } type TestBeanInterface interface { @@ -67,29 +67,29 @@ func TestBeanDefinition(t *testing.T) { v := reflect.ValueOf(a) bean := makeBean(v.Type(), v, nil, "test") - assert.Equal(t, bean.Name(), "test") - assert.Equal(t, bean.Type(), reflect.TypeFor[*TestBean]()) - assert.Equal(t, bean.Value().Interface(), a) - assert.Equal(t, bean.Interface(), a) + assert.That(t, bean.Name()).Equal("test") + assert.That(t, bean.Type()).Equal(reflect.TypeFor[*TestBean]()) + assert.That(t, bean.Value().Interface()).Equal(a) + assert.That(t, bean.Interface()).Equal(a) assert.Nil(t, bean.Callable()) bean.SetStatus(StatusCreated) - assert.Equal(t, StatusCreated, bean.Status()) + assert.That(t, StatusCreated).Equal(bean.Status()) bean.SetCaller(1) - assert.String(t, bean.FileLine()).HasSuffix("gs/internal/gs_bean/bean_test.go:79") + assert.ThatString(t, bean.FileLine()).HasSuffix("gs/internal/gs_bean/bean_test.go:79") bean.SetName("test-1") - assert.Equal(t, bean.Name(), "test-1") + assert.That(t, bean.Name()).Equal("test-1") beanType, beanName := bean.TypeAndName() - assert.Equal(t, beanType, reflect.TypeFor[*TestBean]()) - assert.Equal(t, beanName, "test-1") - assert.Matches(t, bean.String(), `name=test-1 .*/gs/internal/gs_bean/bean_test.go:79`) + assert.That(t, beanType).Equal(reflect.TypeFor[*TestBean]()) + assert.That(t, beanName).Equal("test-1") + assert.ThatString(t, bean.String()).Matches(`name=test-1 .*/gs/internal/gs_bean/bean_test.go:79`) assert.Nil(t, bean.BeanRuntime.Callable()) - assert.Equal(t, bean.BeanRuntime.Status(), StatusWired) - assert.Equal(t, bean.BeanRuntime.String(), "test-1") + assert.That(t, bean.BeanRuntime.Status()).Equal(StatusWired) + assert.That(t, bean.BeanRuntime.String()).Equal("test-1") }) t.Run("depends on", func(t *testing.T) { @@ -97,7 +97,7 @@ func TestBeanDefinition(t *testing.T) { bean := makeBean(v.Type(), v, nil, "test") selector := gs.BeanSelectorFor[*http.ServeMux]() bean.SetDependsOn(selector) - assert.Equal(t, bean.DependsOn(), []gs.BeanSelector{selector}) + assert.That(t, bean.DependsOn()).Equal([]gs.BeanSelector{selector}) }) t.Run("init function", func(t *testing.T) { @@ -127,13 +127,13 @@ func TestBeanDefinition(t *testing.T) { bean.SetInit(func(TestBeanInterface) (int, error) { return 0, nil }) }, "init should be func\\(bean\\) or func\\(bean\\)error") bean.SetInit(InitTestBean) - assert.Equal(t, util.FuncName(bean.Init()), "gs_bean.InitTestBean") + assert.That(t, util.FuncName(bean.Init())).Equal("gs_bean.InitTestBean") bean.SetInit(InitTestBeanV2) - assert.Equal(t, util.FuncName(bean.Init()), "gs_bean.InitTestBeanV2") + assert.That(t, util.FuncName(bean.Init())).Equal("gs_bean.InitTestBeanV2") bean.SetInitMethod("Init") - assert.Equal(t, util.FuncName(bean.Init()), "gs_bean.(*TestBean).Init") + assert.That(t, util.FuncName(bean.Init())).Equal("gs_bean.(*TestBean).Init") bean.SetInitMethod("InitV2") - assert.Equal(t, util.FuncName(bean.Init()), "gs_bean.(*TestBean).InitV2") + assert.That(t, util.FuncName(bean.Init())).Equal("gs_bean.(*TestBean).InitV2") assert.Panic(t, func() { bean.SetInitMethod("InitV3") }, "method InitV3 not found on type \\*gs_bean.TestBean") @@ -166,13 +166,13 @@ func TestBeanDefinition(t *testing.T) { bean.SetDestroy(func(TestBeanInterface) (int, error) { return 0, nil }) }, "destroy should be func\\(bean\\) or func\\(bean\\)error") bean.SetDestroy(DestroyTestBean) - assert.Equal(t, util.FuncName(bean.Destroy()), "gs_bean.DestroyTestBean") + assert.That(t, util.FuncName(bean.Destroy())).Equal("gs_bean.DestroyTestBean") bean.SetDestroy(DestroyTestBeanV2) - assert.Equal(t, util.FuncName(bean.Destroy()), "gs_bean.DestroyTestBeanV2") + assert.That(t, util.FuncName(bean.Destroy())).Equal("gs_bean.DestroyTestBeanV2") bean.SetDestroyMethod("Destroy") - assert.Equal(t, util.FuncName(bean.Destroy()), "gs_bean.(*TestBean).Destroy") + assert.That(t, util.FuncName(bean.Destroy())).Equal("gs_bean.(*TestBean).Destroy") bean.SetDestroyMethod("DestroyV2") - assert.Equal(t, util.FuncName(bean.Destroy()), "gs_bean.(*TestBean).DestroyV2") + assert.That(t, util.FuncName(bean.Destroy())).Equal("gs_bean.(*TestBean).DestroyV2") assert.Panic(t, func() { bean.SetDestroyMethod("DestroyV3") }, "method DestroyV3 not found on type \\*gs_bean.TestBean") @@ -182,9 +182,9 @@ func TestBeanDefinition(t *testing.T) { v := reflect.ValueOf(&TestBean{}) bean := makeBean(v.Type(), v, nil, "test") bean.SetExport(gs.As[TestBeanInterface]()) - assert.Equal(t, len(bean.Exports()), 1) + assert.That(t, len(bean.Exports())).Equal(1) bean.SetExport(gs.As[TestBeanInterface]()) - assert.Equal(t, len(bean.Exports()), 1) + assert.That(t, len(bean.Exports())).Equal(1) assert.Panic(t, func() { bean.SetExport(reflect.TypeFor[int]()) }, "only interface type can be exported") @@ -197,7 +197,7 @@ func TestBeanDefinition(t *testing.T) { v := reflect.ValueOf(&TestBean{}) bean := makeBean(v.Type(), v, nil, "test") bean.OnProfiles("dev,test") - assert.Equal(t, len(bean.Conditions()), 1) + assert.That(t, len(bean.Conditions())).Equal(1) t.Run("no profile property", func(t *testing.T) { ctrl := gomock.NewController(t) @@ -274,7 +274,7 @@ func TestBeanDefinition(t *testing.T) { Includes: []string{"New.*"}, }) assert.NotNil(t, bean.Configuration()) - assert.Equal(t, bean.Configuration().Includes, []string{"New.*"}) + assert.That(t, bean.Configuration().Includes).Equal([]string{"New.*"}) }) t.Run("mock success", func(t *testing.T) { @@ -309,23 +309,23 @@ func TestNewBean(t *testing.T) { t.Run("object", func(t *testing.T) { bean := NewBean(&TestBean{}) beanX := bean.BeanRegistration().(*BeanDefinition) - assert.Equal(t, beanX.Name(), "TestBean") - assert.Equal(t, beanX.Type(), reflect.TypeFor[*TestBean]()) + assert.That(t, beanX.Name()).Equal("TestBean") + assert.That(t, beanX.Type()).Equal(reflect.TypeFor[*TestBean]()) }) t.Run("object - reflect.Value", func(t *testing.T) { bean := NewBean(reflect.ValueOf(&TestBean{})) beanX := bean.BeanRegistration().(*BeanDefinition) - assert.Equal(t, beanX.Name(), "TestBean") - assert.Equal(t, beanX.Type(), reflect.TypeFor[*TestBean]()) + assert.That(t, beanX.Name()).Equal("TestBean") + assert.That(t, beanX.Type()).Equal(reflect.TypeFor[*TestBean]()) }) t.Run("function - reflect.Value", func(t *testing.T) { fn := func(int, int) string { return "" } bean := NewBean(reflect.ValueOf(fn)).Name("TestFunc") beanX := bean.BeanRegistration().(*BeanDefinition) - assert.Equal(t, beanX.Name(), "TestFunc") - assert.Equal(t, beanX.Type(), reflect.TypeOf(fn)) + assert.That(t, beanX.Name()).Equal("TestFunc") + assert.That(t, beanX.Type()).Equal(reflect.TypeOf(fn)) }) t.Run("constructor error", func(t *testing.T) { @@ -355,31 +355,31 @@ func TestNewBean(t *testing.T) { fn := func(int, int) *TestBean { return nil } bean := NewBean(fn).Name("NewTestBean") beanX := bean.BeanRegistration().(*BeanDefinition) - assert.Equal(t, beanX.Name(), "NewTestBean") - assert.Equal(t, beanX.Type(), reflect.TypeFor[*TestBean]()) + assert.That(t, beanX.Name()).Equal("NewTestBean") + assert.That(t, beanX.Type()).Equal(reflect.TypeFor[*TestBean]()) }) t.Run("method - 1", func(t *testing.T) { bean := NewBean((*TestBean).Clone) beanX := bean.BeanRegistration().(*BeanDefinition) - assert.Equal(t, beanX.Name(), "Clone") - assert.Equal(t, len(beanX.Conditions()), 1) + assert.That(t, beanX.Name()).Equal("Clone") + assert.That(t, len(beanX.Conditions())).Equal(1) }) t.Run("method - 2", func(t *testing.T) { parent := NewBean(&TestBean{}) bean := NewBean((*TestBean).Clone, parent) beanX := bean.BeanRegistration().(*BeanDefinition) - assert.Equal(t, beanX.Name(), "Clone") - assert.Equal(t, len(beanX.Conditions()), 1) + assert.That(t, beanX.Name()).Equal("Clone") + assert.That(t, len(beanX.Conditions())).Equal(1) }) t.Run("method - 3", func(t *testing.T) { parent := NewBean(&TestBean{}) bean := NewBean((*TestBean).Clone, gs_arg.Index(0, parent)) beanX := bean.BeanRegistration().(*BeanDefinition) - assert.Equal(t, beanX.Name(), "Clone") - assert.Equal(t, len(beanX.Conditions()), 1) + assert.That(t, beanX.Name()).Equal("Clone") + assert.That(t, len(beanX.Conditions())).Equal(1) }) t.Run("method - 4", func(t *testing.T) { @@ -388,8 +388,8 @@ func TestNewBean(t *testing.T) { ) bean := NewBean((*TestBean).Clone, parent) beanX := bean.BeanRegistration().(*BeanDefinition) - assert.Equal(t, beanX.Name(), "Clone") - assert.Equal(t, len(beanX.Conditions()), 1) + assert.That(t, beanX.Name()).Equal("Clone") + assert.That(t, len(beanX.Conditions())).Equal(1) }) t.Run("method - 5", func(t *testing.T) { @@ -398,8 +398,8 @@ func TestNewBean(t *testing.T) { ) bean := NewBean((*TestBean).Clone, gs_arg.Index(0, parent)) beanX := bean.BeanRegistration().(*BeanDefinition) - assert.Equal(t, beanX.Name(), "Clone") - assert.Equal(t, len(beanX.Conditions()), 1) + assert.That(t, beanX.Name()).Equal("Clone") + assert.That(t, len(beanX.Conditions())).Equal(1) }) t.Run("method error - 1", func(t *testing.T) { diff --git a/gs/internal/gs_cond/cond_test.go b/gs/internal/gs_cond/cond_test.go index c1cd09d2..67d06ebe 100644 --- a/gs/internal/gs_cond/cond_test.go +++ b/gs/internal/gs_cond/cond_test.go @@ -35,61 +35,61 @@ var ( func TestConditionString(t *testing.T) { c := OnFunc(func(ctx gs.CondContext) (bool, error) { return false, nil }) - assert.Equal(t, fmt.Sprint(c), `OnFunc(fn=gs_cond.TestConditionString.func1)`) + assert.That(t, fmt.Sprint(c)).Equal(`OnFunc(fn=gs_cond.TestConditionString.func1)`) c = OnProperty("a").HavingValue("123") - assert.Equal(t, fmt.Sprint(c), `OnProperty(name=a, havingValue=123)`) + assert.That(t, fmt.Sprint(c)).Equal(`OnProperty(name=a, havingValue=123)`) c = OnProperty("a").HavingValue("123").MatchIfMissing() - assert.Equal(t, fmt.Sprint(c), `OnProperty(name=a, havingValue=123, matchIfMissing)`) + assert.That(t, fmt.Sprint(c)).Equal(`OnProperty(name=a, havingValue=123, matchIfMissing)`) c = OnMissingProperty("a") - assert.Equal(t, fmt.Sprint(c), `OnMissingProperty(name=a)`) + assert.That(t, fmt.Sprint(c)).Equal(`OnMissingProperty(name=a)`) c = OnBean[any]("a") - assert.Equal(t, fmt.Sprint(c), `OnBean(selector={Name:a})`) + assert.That(t, fmt.Sprint(c)).Equal(`OnBean(selector={Name:a})`) c = OnBean[error]() - assert.Equal(t, fmt.Sprint(c), `OnBean(selector={Type:error})`) + assert.That(t, fmt.Sprint(c)).Equal(`OnBean(selector={Type:error})`) c = OnMissingBean[any]("a") - assert.Equal(t, fmt.Sprint(c), `OnMissingBean(selector={Name:a})`) + assert.That(t, fmt.Sprint(c)).Equal(`OnMissingBean(selector={Name:a})`) c = OnMissingBeanSelector(gs.BeanSelectorFor[error]()) - assert.Equal(t, fmt.Sprint(c), `OnMissingBean(selector={Type:error})`) + assert.That(t, fmt.Sprint(c)).Equal(`OnMissingBean(selector={Type:error})`) c = OnSingleBean[any]("a") - assert.Equal(t, fmt.Sprint(c), `OnSingleBean(selector={Name:a})`) + assert.That(t, fmt.Sprint(c)).Equal(`OnSingleBean(selector={Name:a})`) c = OnSingleBeanSelector(gs.BeanSelectorFor[error]()) - assert.Equal(t, fmt.Sprint(c), `OnSingleBean(selector={Type:error})`) + assert.That(t, fmt.Sprint(c)).Equal(`OnSingleBean(selector={Type:error})`) c = OnExpression("a") - assert.Equal(t, fmt.Sprint(c), `OnExpression(expression=a)`) + assert.That(t, fmt.Sprint(c)).Equal(`OnExpression(expression=a)`) c = Not(OnBean[any]("a")) - assert.Equal(t, fmt.Sprint(c), `Not(OnBean(selector={Name:a}))`) + assert.That(t, fmt.Sprint(c)).Equal(`Not(OnBean(selector={Name:a}))`) c = Or(OnBean[any]("a")) - assert.Equal(t, fmt.Sprint(c), `OnBean(selector={Name:a})`) + assert.That(t, fmt.Sprint(c)).Equal(`OnBean(selector={Name:a})`) c = Or(OnBean[any]("a"), OnBean[any]("b")) - assert.Equal(t, fmt.Sprint(c), `Or(OnBean(selector={Name:a}), OnBean(selector={Name:b}))`) + assert.That(t, fmt.Sprint(c)).Equal(`Or(OnBean(selector={Name:a}), OnBean(selector={Name:b}))`) c = And(OnBean[any]("a")) - assert.Equal(t, fmt.Sprint(c), `OnBean(selector={Name:a})`) + assert.That(t, fmt.Sprint(c)).Equal(`OnBean(selector={Name:a})`) c = And( OnBeanSelector(gs.BeanSelectorImpl{Name: "a"}), OnBeanSelector(gs.BeanSelectorImpl{Name: "b"}), ) - assert.Equal(t, fmt.Sprint(c), `And(OnBean(selector={Name:a}), OnBean(selector={Name:b}))`) + assert.That(t, fmt.Sprint(c)).Equal(`And(OnBean(selector={Name:a}), OnBean(selector={Name:b}))`) c = None(OnBean[any]("a")) - assert.Equal(t, fmt.Sprint(c), `Not(OnBean(selector={Name:a}))`) + assert.That(t, fmt.Sprint(c)).Equal(`Not(OnBean(selector={Name:a}))`) c = None(OnBean[any]("a"), OnBean[any]("b")) - assert.Equal(t, fmt.Sprint(c), `None(OnBean(selector={Name:a}), OnBean(selector={Name:b}))`) + assert.That(t, fmt.Sprint(c)).Equal(`None(OnBean(selector={Name:a}), OnBean(selector={Name:b}))`) c = And( OnBean[any]("a"), @@ -98,7 +98,7 @@ func TestConditionString(t *testing.T) { Not(OnBean[any]("c")), ), ) - assert.Equal(t, fmt.Sprint(c), `And(OnBean(selector={Name:a}), Or(OnBean(selector={Name:b}), Not(OnBean(selector={Name:c}))))`) + assert.That(t, fmt.Sprint(c)).Equal(`And(OnBean(selector={Name:a}), Or(OnBean(selector={Name:b}), Not(OnBean(selector={Name:c}))))`) } func TestOnFunc(t *testing.T) { @@ -115,7 +115,7 @@ func TestOnFunc(t *testing.T) { fn := func(ctx gs.CondContext) (bool, error) { return false, errors.New("test error") } cond := OnFunc(fn) _, err := cond.Matches(nil) - assert.Error(t, err, "test error") + assert.ThatError(t, err).Matches("test error") }) } @@ -197,7 +197,7 @@ func TestOnProperty(t *testing.T) { ctx.EXPECT().Prop("test.prop").Return("42") cond := OnProperty("test.prop").HavingValue("expr:invalid syntax") _, err := cond.Matches(ctx) - assert.Error(t, err, "eval \\\"invalid syntax\\\" returns error") + assert.ThatError(t, err).Matches("eval \\\"invalid syntax\\\" returns error") }) }) } @@ -256,7 +256,7 @@ func TestOnBean(t *testing.T) { ctx.EXPECT().Find(gomock.Any()).Return(nil, errors.New("test error")) cond := OnBean[any]("b") ok, err := cond.Matches(ctx) - assert.Error(t, err, "test error") + assert.ThatError(t, err).Matches("test error") assert.False(t, ok) }) } @@ -292,7 +292,7 @@ func TestOnMissingBean(t *testing.T) { ctx.EXPECT().Find(gomock.Any()).Return(nil, errors.New("test error")) cond := OnMissingBean[any]("b") ok, err := cond.Matches(ctx) - assert.Error(t, err, "test error") + assert.ThatError(t, err).Matches("test error") assert.False(t, ok) }) } @@ -326,7 +326,7 @@ func TestOnSingleBean(t *testing.T) { ctx.EXPECT().Find(gomock.Any()).Return(nil, errors.New("test error")) cond := OnSingleBean[any]("b") ok, err := cond.Matches(ctx) - assert.Error(t, err, "test error") + assert.ThatError(t, err).Matches("test error") assert.False(t, ok) }) } @@ -363,7 +363,7 @@ func TestNot(t *testing.T) { ctx.EXPECT().Find(gomock.Any()).Return(nil, errors.New("test error")) cond := OnSingleBean[any]("b") ok, err := Not(cond).Matches(ctx) - assert.Error(t, err, "test error") + assert.ThatError(t, err).Matches("test error") assert.False(t, ok) }) } @@ -377,7 +377,7 @@ func TestAnd(t *testing.T) { t.Run("one condition", func(t *testing.T) { cond := And(trueCond) - assert.Equal(t, trueCond, cond) + assert.That(t, trueCond).Equal(cond) }) t.Run("two conditions | true", func(t *testing.T) { @@ -401,7 +401,7 @@ func TestAnd(t *testing.T) { ctx.EXPECT().Find(gomock.Any()).Return(nil, errors.New("test error")) cond := OnSingleBean[any]("b") ok, err := And(cond, trueCond).Matches(ctx) - assert.Error(t, err, "test error") + assert.ThatError(t, err).Matches("test error") assert.False(t, ok) }) } @@ -415,7 +415,7 @@ func TestOr(t *testing.T) { t.Run("one condition", func(t *testing.T) { cond := Or(trueCond) - assert.Equal(t, trueCond, cond) + assert.That(t, trueCond).Equal(cond) }) t.Run("two conditions | true", func(t *testing.T) { @@ -439,7 +439,7 @@ func TestOr(t *testing.T) { ctx.EXPECT().Find(gomock.Any()).Return(nil, errors.New("test error")) cond := OnSingleBean[any]("b") ok, err := Or(cond, trueCond).Matches(ctx) - assert.Error(t, err, "test error") + assert.ThatError(t, err).Matches("test error") assert.False(t, ok) }) } @@ -479,7 +479,7 @@ func TestNone(t *testing.T) { ctx.EXPECT().Find(gomock.Any()).Return(nil, errors.New("test error")) cond := OnSingleBean[any]("b") ok, err := None(cond, trueCond).Matches(ctx) - assert.Error(t, err, "test error") + assert.ThatError(t, err).Matches("test error") assert.False(t, ok) }) } diff --git a/gs/internal/gs_cond/expr_test.go b/gs/internal/gs_cond/expr_test.go index 5b48f924..7cf72ecb 100644 --- a/gs/internal/gs_cond/expr_test.go +++ b/gs/internal/gs_cond/expr_test.go @@ -25,7 +25,7 @@ import ( func TestEvalExpr(t *testing.T) { _, err := EvalExpr("$", "3") - assert.Error(t, err, "doesn't return bool value") + assert.ThatError(t, err).Matches("doesn't return bool value") ok, err := EvalExpr("int($)==3", "3") assert.Nil(t, err) diff --git a/gs/internal/gs_conf/cmd_test.go b/gs/internal/gs_conf/cmd_test.go index 0e1ab281..15cf8291 100644 --- a/gs/internal/gs_conf/cmd_test.go +++ b/gs/internal/gs_conf/cmd_test.go @@ -50,8 +50,8 @@ func TestCommandArgs(t *testing.T) { p := conf.New() err := NewCommandArgs().CopyTo(p) assert.Nil(t, err) - assert.Equal(t, "go-spring", p.Get("name")) - assert.Equal(t, "true", p.Get("debug")) + assert.That(t, "go-spring").Equal(p.Get("name")) + assert.That(t, "true").Equal(p.Get("debug")) }) t.Run("missing arg", func(t *testing.T) { @@ -59,7 +59,7 @@ func TestCommandArgs(t *testing.T) { props := conf.New() err := NewCommandArgs().CopyTo(props) - assert.Error(t, err, "cmd option -D needs arg") + assert.ThatError(t, err).Matches("cmd option -D needs arg") }) t.Run("set return error", func(t *testing.T) { @@ -69,7 +69,7 @@ func TestCommandArgs(t *testing.T) { "debug": []string{"true"}, }) err := NewCommandArgs().CopyTo(p) - assert.Error(t, err, "property conflict at path debug") + assert.ThatError(t, err).Matches("property conflict at path debug") }) t.Run("custom prefix", func(t *testing.T) { @@ -82,7 +82,7 @@ func TestCommandArgs(t *testing.T) { props := conf.New() err := NewCommandArgs().CopyTo(props) assert.Nil(t, err) - assert.Equal(t, "8080", props.Get("port")) + assert.That(t, "8080").Equal(props.Get("port")) }) t.Run("ignore other args", func(t *testing.T) { @@ -91,7 +91,7 @@ func TestCommandArgs(t *testing.T) { props := conf.New() err := NewCommandArgs().CopyTo(props) assert.Nil(t, err) - assert.Equal(t, "prod", props.Get("env")) + assert.That(t, "prod").Equal(props.Get("env")) assert.False(t, props.Has("--log-level")) assert.False(t, props.Has("-v")) }) diff --git a/gs/internal/gs_conf/conf_test.go b/gs/internal/gs_conf/conf_test.go index 5dd49a33..6a92ba22 100644 --- a/gs/internal/gs_conf/conf_test.go +++ b/gs/internal/gs_conf/conf_test.go @@ -39,14 +39,14 @@ func TestAppConfig(t *testing.T) { t.Cleanup(clean) _ = os.Setenv("GS_SPRING_APP_CONFIG-LOCAL_DIR", "${a}") _, err := NewAppConfig().Refresh() - assert.Error(t, err, `resolve string "\${a}" error << property a not exist`) + assert.ThatError(t, err).Matches(`resolve string "\${a}" error << property a not exist`) }) t.Run("resolve error - 2", func(t *testing.T) { t.Cleanup(clean) _ = os.Setenv("GS_SPRING_APP_CONFIG-REMOTE_DIR", "${a}") _, err := NewAppConfig().Refresh() - assert.Error(t, err, `resolve string "\${a}" error << property a not exist`) + assert.ThatError(t, err).Matches(`resolve string "\${a}" error << property a not exist`) }) t.Run("success", func(t *testing.T) { @@ -55,7 +55,7 @@ func TestAppConfig(t *testing.T) { _ = os.Setenv("GS_SPRING_APP_CONFIG-REMOTE_DIR", "./testdata/conf/remote") p, err := NewAppConfig().Refresh() assert.Nil(t, err) - assert.Equal(t, p.Data(), map[string]string{ + assert.That(t, p.Data()).Equal(map[string]string{ "spring.app.config-local.dir": "./testdata/conf", "spring.app.config-remote.dir": "./testdata/conf/remote", "spring.app.name": "remote", @@ -68,15 +68,15 @@ func TestAppConfig(t *testing.T) { _ = os.Setenv("GS_A", "a") _ = os.Setenv("GS_A_B", "a.b") _, err := NewAppConfig().Refresh() - assert.Error(t, err, "property conflict at path a.b") + assert.ThatError(t, err).Matches("property conflict at path a.b") }) t.Run("merge error - 2", func(t *testing.T) { t.Cleanup(clean) _ = os.Setenv("GS_SPRING_APP_CONFIG-LOCAL_DIR", "./testdata/conf") - _ = sysconf.Set("http.server[0].addr", "0.0.0.0:8080") + sysconf.Set("http.server[0].addr", "0.0.0.0:8080") _, err := NewAppConfig().Refresh() - assert.Error(t, err, "property conflict at path http.server.addr") + assert.ThatError(t, err).Matches("property conflict at path http.server.addr") }) } @@ -87,7 +87,7 @@ func TestBootConfig(t *testing.T) { t.Cleanup(clean) _ = os.Setenv("GS_SPRING_APP_CONFIG-LOCAL_DIR", "${a}") _, err := NewBootConfig().Refresh() - assert.Error(t, err, `resolve string "\${a}" error << property a not exist`) + assert.ThatError(t, err).Matches(`resolve string "\${a}" error << property a not exist`) }) t.Run("success", func(t *testing.T) { @@ -95,7 +95,7 @@ func TestBootConfig(t *testing.T) { _ = os.Setenv("GS_SPRING_APP_CONFIG-LOCAL_DIR", "./testdata/conf") p, err := NewBootConfig().Refresh() assert.Nil(t, err) - assert.Equal(t, p.Data(), map[string]string{ + assert.That(t, p.Data()).Equal(map[string]string{ "spring.app.config-local.dir": "./testdata/conf", "spring.app.name": "test", "http.server.addr": "0.0.0.0:8080", @@ -107,15 +107,15 @@ func TestBootConfig(t *testing.T) { _ = os.Setenv("GS_A", "a") _ = os.Setenv("GS_A_B", "a.b") _, err := NewBootConfig().Refresh() - assert.Error(t, err, "property conflict at path a.b") + assert.ThatError(t, err).Matches("property conflict at path a.b") }) t.Run("merge error - 2", func(t *testing.T) { t.Cleanup(clean) _ = os.Setenv("GS_SPRING_APP_CONFIG-LOCAL_DIR", "./testdata/conf") - _ = sysconf.Set("http.server[0].addr", "0.0.0.0:8080") + sysconf.Set("http.server[0].addr", "0.0.0.0:8080") _, err := NewBootConfig().Refresh() - assert.Error(t, err, "property conflict at path http.server.addr") + assert.ThatError(t, err).Matches("property conflict at path http.server.addr") }) } @@ -126,7 +126,7 @@ func TestPropertySources(t *testing.T) { t.Cleanup(clean) ps := NewPropertySources(ConfigTypeLocal, "app") ps.AddDir("non_existent_dir") - assert.Equal(t, 1, len(ps.extraDirs)) + assert.That(t, 1).Equal(len(ps.extraDirs)) }) t.Run("add dir error - 2", func(t *testing.T) { @@ -153,7 +153,7 @@ func TestPropertySources(t *testing.T) { t.Cleanup(clean) ps := NewPropertySources(ConfigTypeLocal, "app") ps.AddFile("non_existent_file") - assert.Equal(t, 1, len(ps.extraFiles)) + assert.That(t, 1).Equal(len(ps.extraFiles)) }) t.Run("add file error - 2", func(t *testing.T) { @@ -180,12 +180,12 @@ func TestPropertySources(t *testing.T) { t.Cleanup(clean) ps := NewPropertySources(ConfigTypeLocal, "app") ps.AddFile("./testdata/conf/app.properties") - assert.Equal(t, 1, len(ps.extraFiles)) + assert.That(t, 1).Equal(len(ps.extraFiles)) ps.AddDir("./testdata/conf") - assert.Equal(t, 1, len(ps.extraDirs)) + assert.That(t, 1).Equal(len(ps.extraDirs)) ps.Reset() - assert.Equal(t, 0, len(ps.extraFiles)) - assert.Equal(t, 0, len(ps.extraDirs)) + assert.That(t, 0).Equal(len(ps.extraFiles)) + assert.That(t, 0).Equal(len(ps.extraDirs)) }) t.Run("getDefaultDir - 1", func(t *testing.T) { @@ -193,7 +193,7 @@ func TestPropertySources(t *testing.T) { ps := NewPropertySources(ConfigTypeLocal, "app") dir, err := ps.getDefaultDir(conf.Map(nil)) assert.Nil(t, err) - assert.Equal(t, "./conf", dir) + assert.That(t, "./conf").Equal(dir) }) t.Run("getDefaultDir - 2", func(t *testing.T) { @@ -201,7 +201,7 @@ func TestPropertySources(t *testing.T) { ps := NewPropertySources(ConfigTypeRemote, "app") dir, err := ps.getDefaultDir(conf.Map(nil)) assert.Nil(t, err) - assert.Equal(t, "./conf/remote", dir) + assert.That(t, "./conf/remote").Equal(dir) }) t.Run("getFiles - 1", func(t *testing.T) { @@ -209,7 +209,7 @@ func TestPropertySources(t *testing.T) { ps := NewPropertySources(ConfigTypeLocal, "app") files, err := ps.getFiles("./conf", conf.Map(nil)) assert.Nil(t, err) - assert.Equal(t, files, []string{ + assert.That(t, files).Equal([]string{ "./conf/app.properties", "./conf/app.yaml", "./conf/app.toml", @@ -225,7 +225,7 @@ func TestPropertySources(t *testing.T) { ps := NewPropertySources(ConfigTypeLocal, "app") files, err := ps.getFiles("./conf", p) assert.Nil(t, err) - assert.Equal(t, files, []string{ + assert.That(t, files).Equal([]string{ "./conf/app.properties", "./conf/app.yaml", "./conf/app.toml", @@ -247,14 +247,14 @@ func TestPropertySources(t *testing.T) { ps.AddFile("./testdata/conf/app.properties") files, err := ps.loadFiles(conf.Map(nil)) assert.Nil(t, err) - assert.Equal(t, 1, len(files)) + assert.That(t, 1).Equal(len(files)) }) t.Run("loadFiles - getDefaultDir error", func(t *testing.T) { t.Cleanup(clean) ps := NewPropertySources("invalid", "app") _, err := ps.loadFiles(conf.Map(nil)) - assert.Error(t, err, "unknown config type: invalid") + assert.ThatError(t, err).Matches("unknown config type: invalid") }) t.Run("loadFiles - getFiles error", func(t *testing.T) { @@ -264,7 +264,7 @@ func TestPropertySources(t *testing.T) { }) ps := NewPropertySources(ConfigTypeLocal, "app") _, err := ps.loadFiles(p) - assert.Error(t, err, `resolve string "\${a}" error << property a not exist`) + assert.ThatError(t, err).Matches(`resolve string "\${a}" error << property a not exist`) }) t.Run("loadFiles - resolve error", func(t *testing.T) { @@ -272,7 +272,7 @@ func TestPropertySources(t *testing.T) { ps := NewPropertySources(ConfigTypeLocal, "app") ps.AddFile("./testdata/conf/app-${a}.properties") _, err := ps.loadFiles(conf.Map(nil)) - assert.Error(t, err, "property a not exist") + assert.ThatError(t, err).Matches("property a not exist") }) t.Run("loadFiles - confLoad error", func(t *testing.T) { @@ -280,6 +280,6 @@ func TestPropertySources(t *testing.T) { ps := NewPropertySources(ConfigTypeLocal, "app") ps.AddFile("./testdata/conf/error.json") _, err := ps.loadFiles(conf.Map(nil)) - assert.Error(t, err, "cannot unmarshal .*") + assert.ThatError(t, err).Matches("cannot unmarshal .*") }) } diff --git a/gs/internal/gs_conf/env_test.go b/gs/internal/gs_conf/env_test.go index 906cf5d8..d7499cb3 100644 --- a/gs/internal/gs_conf/env_test.go +++ b/gs/internal/gs_conf/env_test.go @@ -31,7 +31,7 @@ func TestEnvironment(t *testing.T) { props := conf.New() err := NewEnvironment().CopyTo(props) assert.Nil(t, err) - assert.Equal(t, 0, len(props.Keys())) + assert.That(t, 0).Equal(len(props.Keys())) }) t.Run("normal", func(t *testing.T) { @@ -44,8 +44,8 @@ func TestEnvironment(t *testing.T) { props := conf.New() err := NewEnvironment().CopyTo(props) assert.Nil(t, err) - assert.Equal(t, props.Get("db.host"), "db1") - assert.Equal(t, props.Get("API_KEY"), "key123") + assert.That(t, props.Get("db.host")).Equal("db1") + assert.That(t, props.Get("API_KEY")).Equal("key123") }) t.Run("custom patterns", func(t *testing.T) { @@ -62,7 +62,7 @@ func TestEnvironment(t *testing.T) { props := conf.New() err := NewEnvironment().CopyTo(props) assert.Nil(t, err) - assert.Equal(t, props.Get("TEST_PUBLIC"), "yes") + assert.That(t, props.Get("TEST_PUBLIC")).Equal("yes") assert.False(t, props.Has("TEST_INTERNAL")) }) @@ -73,7 +73,7 @@ func TestEnvironment(t *testing.T) { }() props := conf.New() err := NewEnvironment().CopyTo(props) - assert.Error(t, err, "error parsing regexp") + assert.ThatError(t, err).Matches("error parsing regexp") }) t.Run("invalid regex - exclude", func(t *testing.T) { @@ -83,7 +83,7 @@ func TestEnvironment(t *testing.T) { }() props := conf.New() err := NewEnvironment().CopyTo(props) - assert.Error(t, err, "error parsing regexp") + assert.ThatError(t, err).Matches("error parsing regexp") }) t.Run("set return error", func(t *testing.T) { @@ -95,6 +95,6 @@ func TestEnvironment(t *testing.T) { "db": []string{"db2"}, }) err := NewEnvironment().CopyTo(props) - assert.Error(t, err, "property conflict at path db.host") + assert.ThatError(t, err).Matches("property conflict at path db.host") }) } diff --git a/gs/internal/gs_core/core_test.go b/gs/internal/gs_core/core_test.go index 80b3a65a..0994722f 100644 --- a/gs/internal/gs_core/core_test.go +++ b/gs/internal/gs_core/core_test.go @@ -45,13 +45,13 @@ func TestContainer(t *testing.T) { }), ) err := c.Refresh(conf.New()) - assert.Error(t, err, "condition error") + assert.ThatError(t, err).Matches("condition error") }) t.Run("inject error", func(t *testing.T) { c := New() c.Provide(func(addr string) *http.Server { return nil }) err := c.Refresh(conf.New()) - assert.Error(t, err, "parse tag .* error: invalid syntax") + assert.ThatError(t, err).Matches("parse tag .* error: invalid syntax") }) } diff --git a/gs/internal/gs_core/injecting/injecting_test.go b/gs/internal/gs_core/injecting/injecting_test.go index 5778ccfb..deaa8826 100644 --- a/gs/internal/gs_core/injecting/injecting_test.go +++ b/gs/internal/gs_core/injecting/injecting_test.go @@ -208,7 +208,7 @@ func TestInjecting(t *testing.T) { objectBean(&LazyB{}), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "can't find bean") + assert.ThatError(t, err).Matches("can't find bean") }) t.Run("lazy error - 2", func(t *testing.T) { @@ -218,7 +218,7 @@ func TestInjecting(t *testing.T) { objectBean(&LazyB{}), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "found circular autowire") + assert.ThatError(t, err).Matches("found circular autowire") }) t.Run("success", func(t *testing.T) { @@ -289,7 +289,7 @@ func TestInjecting(t *testing.T) { c := &Controller{} err = r.Wire(c) assert.Nil(t, err) - assert.Equal(t, len(c.Loggers), 2) + assert.That(t, len(c.Loggers)).Equal(2) s := &struct { Server *Server `inject:""` @@ -297,14 +297,14 @@ func TestInjecting(t *testing.T) { }{} err = r.Wire(s) assert.Nil(t, err) - assert.Equal(t, s.Service.Status, 1) - assert.Equal(t, s.Service.Filter, myFilter) - assert.Equal(t, s.Service.Int, 100) - assert.Equal(t, s.Service.Str, "hello") - assert.Equal(t, s.Server.addr, "127.0.0.1:9090") - assert.Equal(t, s.Server.arg.connTimeout, 100) - assert.Equal(t, s.Server.arg.readTimeout, 0) - assert.Equal(t, s.Server.arg.writeTimeout, 100) + assert.That(t, s.Service.Status).Equal(1) + assert.That(t, s.Service.Filter).Equal(myFilter) + assert.That(t, s.Service.Int).Equal(100) + assert.That(t, s.Service.Str).Equal("hello") + assert.That(t, s.Server.addr).Equal("127.0.0.1:9090") + assert.That(t, s.Server.arg.connTimeout).Equal(100) + assert.That(t, s.Server.arg.readTimeout).Equal(0) + assert.That(t, s.Server.arg.writeTimeout).Equal(100) err = r.RefreshProperties(conf.Map(map[string]interface{}{ "spring": map[string]interface{}{ @@ -331,11 +331,11 @@ func TestInjecting(t *testing.T) { })) assert.Nil(t, err) - assert.Equal(t, s.Service.Repository.Addr.Value(), "0.0.0.0:5050") + assert.That(t, s.Service.Repository.Addr.Value()).Equal("0.0.0.0:5050") r.Close() - assert.Equal(t, s.Service.Status, 0) + assert.That(t, s.Service.Status).Equal(0) }) t.Run("wire error - 2", func(t *testing.T) { @@ -346,7 +346,7 @@ func TestInjecting(t *testing.T) { })), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "int is not a valid receiver type") + assert.ThatError(t, err).Matches("int is not a valid receiver type") }) t.Run("wire error - 3", func(t *testing.T) { @@ -359,7 +359,7 @@ func TestInjecting(t *testing.T) { objectBean(&SimpleLogger{}).Name("b").Export(gs.As[Logger]()), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "found 2 beans") + assert.ThatError(t, err).Matches("found 2 beans") }) t.Run("wire error - 4", func(t *testing.T) { @@ -370,7 +370,7 @@ func TestInjecting(t *testing.T) { })), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "\\[]int is not a valid receiver type") + assert.ThatError(t, err).Matches("\\[]int is not a valid receiver type") }) t.Run("wire error - 5", func(t *testing.T) { @@ -381,7 +381,7 @@ func TestInjecting(t *testing.T) { })), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "more than one \\* in collection") + assert.ThatError(t, err).Matches("more than one \\* in collection") }) t.Run("wire error - 6", func(t *testing.T) { @@ -394,7 +394,7 @@ func TestInjecting(t *testing.T) { objectBean(&SimpleLogger{}).Name("biz").Export(gs.As[Logger]()), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "found 2 beans") + assert.ThatError(t, err).Matches("found 2 beans") }) t.Run("wire error - 7", func(t *testing.T) { @@ -405,7 +405,7 @@ func TestInjecting(t *testing.T) { })), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "no beans collected") + assert.ThatError(t, err).Matches("no beans collected") }) t.Run("wire error - 8", func(t *testing.T) { @@ -416,7 +416,7 @@ func TestInjecting(t *testing.T) { })), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "can't find bean") + assert.ThatError(t, err).Matches("can't find bean") }) t.Run("wire error - 9", func(t *testing.T) { @@ -430,7 +430,7 @@ func TestInjecting(t *testing.T) { }).Export(gs.As[Logger]()).Name("sys"), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "init error") + assert.ThatError(t, err).Matches("init error") }) t.Run("wire error - 10", func(t *testing.T) { @@ -441,7 +441,7 @@ func TestInjecting(t *testing.T) { })), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "resolve string .* error: invalid syntax") + assert.ThatError(t, err).Matches("resolve string .* error: invalid syntax") }) t.Run("wire error - 11", func(t *testing.T) { @@ -452,7 +452,7 @@ func TestInjecting(t *testing.T) { })), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "resolve string .* error: invalid syntax") + assert.ThatError(t, err).Matches("resolve string .* error: invalid syntax") }) t.Run("wire error - 12", func(t *testing.T) { @@ -466,7 +466,7 @@ func TestInjecting(t *testing.T) { } err := r.Refresh(extractBeans(beans)) assert.Nil(t, err) - assert.Equal(t, s.Loggers, [3]Logger{nil, nil, nil}) + assert.That(t, s.Loggers).Equal([3]Logger{nil, nil, nil}) }) t.Run("wire error - 13", func(t *testing.T) { @@ -478,7 +478,7 @@ func TestInjecting(t *testing.T) { provideBean(NewZeroLogger), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "parse tag '' error: invalid syntax") + assert.ThatError(t, err).Matches("parse tag '' error: invalid syntax") }) t.Run("wire error - 14", func(t *testing.T) { @@ -496,7 +496,7 @@ func TestInjecting(t *testing.T) { } err := r.Refresh(extractBeans(beans)) assert.Nil(t, err) - assert.Equal(t, s.Logger, (*ZeroLogger)(nil)) + assert.That(t, s.Logger).Equal((*ZeroLogger)(nil)) }) t.Run("wire error - 15", func(t *testing.T) { @@ -511,7 +511,7 @@ func TestInjecting(t *testing.T) { }), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "init error") + assert.ThatError(t, err).Matches("init error") }) t.Run("wire error - 16", func(t *testing.T) { @@ -531,7 +531,7 @@ func TestInjecting(t *testing.T) { } err := r.Refresh(extractBeans(beans)) assert.Nil(t, err) - assert.Equal(t, s.Logger, (*ZeroLogger)(nil)) + assert.That(t, s.Logger).Equal((*ZeroLogger)(nil)) }) t.Run("wire error - 17", func(t *testing.T) { @@ -542,7 +542,7 @@ func TestInjecting(t *testing.T) { }), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "name=.* return nil") + assert.ThatError(t, err).Matches("name=.* return nil") }) t.Run("wire error - 22", func(t *testing.T) { @@ -561,7 +561,7 @@ func TestInjecting(t *testing.T) { })), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "parse tag .* error: invalid syntax") + assert.ThatError(t, err).Matches("parse tag .* error: invalid syntax") }) t.Run("wire error - 24", func(t *testing.T) { @@ -572,7 +572,7 @@ func TestInjecting(t *testing.T) { })), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "property config.int not exist") + assert.ThatError(t, err).Matches("property config.int not exist") }) t.Run("wire error - 25", func(t *testing.T) { @@ -583,7 +583,7 @@ func TestInjecting(t *testing.T) { })), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "property svr.config.int not exist") + assert.ThatError(t, err).Matches("property svr.config.int not exist") }) t.Run("wire error - 26", func(t *testing.T) { @@ -603,33 +603,33 @@ func TestWireTag(t *testing.T) { t.Run("empty str", func(t *testing.T) { tag := parseWireTag("") - assert.Equal(t, tag, WireTag{}) - assert.Equal(t, tag.String(), "") + assert.That(t, tag).Equal(WireTag{}) + assert.That(t, tag.String()).Equal("") }) t.Run("only name", func(t *testing.T) { tag := parseWireTag("a") - assert.Equal(t, tag, WireTag{beanName: "a"}) - assert.Equal(t, tag.String(), "a") + assert.That(t, tag).Equal(WireTag{beanName: "a"}) + assert.That(t, tag.String()).Equal("a") }) t.Run("only nullable", func(t *testing.T) { tag := parseWireTag("?") - assert.Equal(t, tag, WireTag{nullable: true}) - assert.Equal(t, tag.String(), "?") + assert.That(t, tag).Equal(WireTag{nullable: true}) + assert.That(t, tag.String()).Equal("?") }) t.Run("name and nullable", func(t *testing.T) { tag := parseWireTag("a?") - assert.Equal(t, tag, WireTag{beanName: "a", nullable: true}) - assert.Equal(t, tag.String(), "a?") + assert.That(t, tag).Equal(WireTag{beanName: "a", nullable: true}) + assert.That(t, tag.String()).Equal("a?") }) t.Run("tags - 1", func(t *testing.T) { tags := []WireTag{ {"a", true}, } - assert.Equal(t, toWireString(tags), "a?") + assert.That(t, toWireString(tags)).Equal("a?") }) t.Run("tags - 2", func(t *testing.T) { @@ -637,7 +637,7 @@ func TestWireTag(t *testing.T) { {"a", true}, {"b", false}, } - assert.Equal(t, toWireString(tags), "a?,b") + assert.That(t, toWireString(tags)).Equal("a?,b") }) t.Run("tags - 3", func(t *testing.T) { @@ -646,7 +646,7 @@ func TestWireTag(t *testing.T) { {"b", false}, {"c", true}, } - assert.Equal(t, toWireString(tags), "a?,b,c?") + assert.That(t, toWireString(tags)).Equal("a?,b,c?") }) } @@ -726,9 +726,9 @@ func TestCircularBean(t *testing.T) { } err = r.Wire(&s) assert.Nil(t, err) - assert.Equal(t, s.A.B, s.B) - assert.Equal(t, s.B.C, s.C) - assert.Equal(t, s.C.A, s.A) + assert.That(t, s.A.B).Equal(s.B) + assert.That(t, s.B.C).Equal(s.C) + assert.That(t, s.C.A).Equal(s.A) }) t.Run("not truly circular - 2", func(t *testing.T) { @@ -747,9 +747,9 @@ func TestCircularBean(t *testing.T) { } err = r.Wire(&s) assert.Nil(t, err) - assert.Equal(t, s.C.D, s.D) - assert.Equal(t, s.D.E, s.E) - assert.Equal(t, s.E.c, s.C) + assert.That(t, s.C.D).Equal(s.D) + assert.That(t, s.D.E).Equal(s.E) + assert.That(t, s.E.c).Equal(s.C) }) t.Run("found circular - 1", func(t *testing.T) { @@ -760,7 +760,7 @@ func TestCircularBean(t *testing.T) { provideBean(NewG), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "found circular autowire") + assert.ThatError(t, err).Matches("found circular autowire") }) t.Run("found circular - 2", func(t *testing.T) { @@ -771,7 +771,7 @@ func TestCircularBean(t *testing.T) { provideBean(NewJ), } err := r.Refresh(extractBeans(beans)) - assert.Error(t, err, "found circular autowire") + assert.ThatError(t, err).Matches("found circular autowire") }) t.Run("found circular - 3", func(t *testing.T) { @@ -794,9 +794,9 @@ func TestCircularBean(t *testing.T) { } err = r.Wire(&s) assert.Nil(t, err) - assert.Equal(t, s.H.i, s.I) - assert.Equal(t, s.I.J, s.J) - assert.Equal(t, s.J.H, s.H) + assert.That(t, s.H.i).Equal(s.I) + assert.That(t, s.I.J).Equal(s.J) + assert.That(t, s.J.H).Equal(s.H) }) } @@ -886,8 +886,8 @@ func TestDestroy(t *testing.T) { err = r.Wire(&s) assert.Nil(t, err) r.Close() - assert.Equal(t, s.DestroyC.value, 2) - assert.Equal(t, s.DestroyE.value, 1) + assert.That(t, s.DestroyC.value).Equal(2) + assert.That(t, s.DestroyE.value).Equal(1) }) } diff --git a/gs/internal/gs_core/resolving/resolving_test.go b/gs/internal/gs_core/resolving/resolving_test.go index b74d9672..43c8c10b 100644 --- a/gs/internal/gs_core/resolving/resolving_test.go +++ b/gs/internal/gs_core/resolving/resolving_test.go @@ -97,7 +97,7 @@ func TestResolving(t *testing.T) { return nil, fmt.Errorf("group error") }) err := r.Refresh(conf.New()) - assert.Error(t, err, "group error") + assert.ThatError(t, err).Matches("group error") }) t.Run("configuration error - 1", func(t *testing.T) { @@ -106,7 +106,7 @@ func TestResolving(t *testing.T) { r.Mock(&TestBean{Value: 9}, gs.BeanSelectorFor[*TestBean]()) r.Mock(&TestBean{Value: 9}, gs.BeanSelectorFor[*TestBean]()) err := r.Refresh(conf.New()) - assert.Error(t, err, "found duplicate mock bean for 'TestBean'") + assert.ThatError(t, err).Matches("found duplicate mock bean for 'TestBean'") }) t.Run("configuration error - 2", func(t *testing.T) { @@ -117,7 +117,7 @@ func TestResolving(t *testing.T) { }, ) err := r.Refresh(conf.New()) - assert.Error(t, err, "error parsing regexp: missing argument to repetition operator: `*`") + assert.ThatError(t, err).Matches("error parsing regexp: missing argument to repetition operator: `*`") }) t.Run("configuration error - 3", func(t *testing.T) { @@ -128,7 +128,7 @@ func TestResolving(t *testing.T) { }, ) err := r.Refresh(conf.New()) - assert.Error(t, err, "error parsing regexp: missing argument to repetition operator: `*`") + assert.ThatError(t, err).Matches("error parsing regexp: missing argument to repetition operator: `*`") }) t.Run("mock error - 1", func(t *testing.T) { @@ -137,7 +137,7 @@ func TestResolving(t *testing.T) { Export(gs.As[Logger](), gs.As[CtxLogger]()) r.Mock(&SimpleLogger{}, gs.BeanSelectorFor[Logger]()) err := r.Refresh(conf.New()) - assert.Error(t, err, "found unimplemented interface") + assert.ThatError(t, err).Matches("found unimplemented interface") }) t.Run("mock error - 2", func(t *testing.T) { @@ -146,7 +146,7 @@ func TestResolving(t *testing.T) { r.Object(&TestBean{Value: 2}).Name("TestBean-2") r.Mock(&TestBean{}, gs.BeanSelectorFor[*TestBean]()) err := r.Refresh(conf.New()) - assert.Error(t, err, "found duplicate mocked beans") + assert.ThatError(t, err).Matches("found duplicate mocked beans") }) t.Run("resolve error - 1", func(t *testing.T) { @@ -157,7 +157,7 @@ func TestResolving(t *testing.T) { }), ) err := r.Refresh(conf.New()) - assert.Error(t, err, "condition matches error: .* << condition error") + assert.ThatError(t, err).Matches("condition matches error: .* << condition error") }) t.Run("resolve error - 2", func(t *testing.T) { @@ -171,7 +171,7 @@ func TestResolving(t *testing.T) { }), ) err := r.Refresh(conf.New()) - assert.Error(t, err, "condition matches error: .* << condition error") + assert.ThatError(t, err).Matches("condition matches error: .* << condition error") }) t.Run("duplicate bean - 1", func(t *testing.T) { @@ -179,7 +179,7 @@ func TestResolving(t *testing.T) { r.Object(&TestBean{Value: 1}) r.Object(&TestBean{Value: 2}) err := r.Refresh(conf.New()) - assert.Error(t, err, "found duplicate beans") + assert.ThatError(t, err).Matches("found duplicate beans") }) t.Run("duplicate bean - 1", func(t *testing.T) { @@ -187,7 +187,7 @@ func TestResolving(t *testing.T) { r.Object(&ZeroLogger{}).Name("a").Export(gs.As[Logger]()) r.Object(&SimpleLogger{}).Name("a").Export(gs.As[Logger]()) err := r.Refresh(conf.New()) - assert.Error(t, err, "found duplicate beans") + assert.ThatError(t, err).Matches("found duplicate beans") }) t.Run("repeat refresh", func(t *testing.T) { @@ -195,7 +195,7 @@ func TestResolving(t *testing.T) { err := r.Refresh(conf.New()) assert.Nil(t, err) err = r.Refresh(conf.New()) - assert.Error(t, err, "container is already refreshing or refreshed") + assert.ThatError(t, err).Matches("container is already refreshing or refreshed") }) t.Run("success", func(t *testing.T) { @@ -222,21 +222,21 @@ func TestResolving(t *testing.T) { { b := r.Object(&http.Server{}). Condition(gs_cond.OnBean[*http.ServeMux]()) - assert.Equal(t, b.BeanRegistration().Name(), "Server") + assert.That(t, b.BeanRegistration().Name()).Equal("Server") } { b := r.Provide(http.NewServeMux).Name("ServeMux-1"). Condition(gs_cond.OnProperty("Enable.ServeMux-1").HavingValue("true")) - assert.Equal(t, b.BeanRegistration().Name(), "ServeMux-1") + assert.That(t, b.BeanRegistration().Name()).Equal("ServeMux-1") } { b := r.Provide(http.NewServeMux).Name("ServeMux-2"). Condition(gs_cond.OnProperty("Enable.ServeMux-2").HavingValue("true")) - assert.Equal(t, b.BeanRegistration().Name(), "ServeMux-2") + assert.That(t, b.BeanRegistration().Name()).Equal("ServeMux-2") } { b := r.Object(&TestBean{Value: 1}).Configuration().Name("TestBean") - assert.Equal(t, b.BeanRegistration().Name(), "TestBean") + assert.That(t, b.BeanRegistration().Name()).Equal("TestBean") r.Mock(&TestBean{Value: 2}, b) } { @@ -244,7 +244,7 @@ func TestResolving(t *testing.T) { Configuration(gs.Configuration{ Excludes: []string{"NewChildV2"}, }) - assert.Equal(t, b.BeanRegistration().Name(), "TestBean-2") + assert.That(t, b.BeanRegistration().Name()).Equal("TestBean-2") r.Mock(&ChildBean{Value: 2}, gs.BeanSelectorFor[*ChildBean]()) } { @@ -262,6 +262,6 @@ func TestResolving(t *testing.T) { }) err := r.Refresh(p) assert.Nil(t, err) - assert.Equal(t, len(r.Beans()), 8) + assert.That(t, len(r.Beans())).Equal(8) }) } diff --git a/gs/internal/gs_dync/dync_test.go b/gs/internal/gs_dync/dync_test.go index 1ab46203..cc34801a 100644 --- a/gs/internal/gs_dync/dync_test.go +++ b/gs/internal/gs_dync/dync_test.go @@ -42,7 +42,7 @@ func (m *MockErrorRefreshable) onRefresh(prop conf.Properties, param conf.BindPa func TestValue(t *testing.T) { var v Value[int] - assert.Equal(t, v.Value(), 0) + assert.That(t, v.Value()).Equal(0) refresh := func(prop conf.Properties) error { return v.onRefresh(prop, conf.BindParam{Key: "key"}) @@ -52,14 +52,14 @@ func TestValue(t *testing.T) { "key": "42", })) assert.Nil(t, err) - assert.Equal(t, v.Value(), 42) + assert.That(t, v.Value()).Equal(42) err = refresh(conf.Map(map[string]interface{}{ "key": map[string]interface{}{ "value": "42", }, })) - assert.Error(t, err, "bind path= type=int error << property key isn't simple value") + assert.ThatError(t, err).Matches("bind path= type=int error << property key isn't simple value") var wg sync.WaitGroup for i := 0; i < 5; i++ { @@ -72,7 +72,7 @@ func TestValue(t *testing.T) { return } <-l.C - assert.Equal(t, v.Value(), 59) + assert.That(t, v.Value()).Equal(59) }() } @@ -86,7 +86,7 @@ func TestValue(t *testing.T) { b, err := json.Marshal(map[string]interface{}{"key": &v}) assert.Nil(t, err) - assert.JsonEqual(t, string(b), `{"key":59}`) + assert.ThatString(t, string(b)).JsonEqual(`{"key":59}`) } func TestDync(t *testing.T) { @@ -106,25 +106,25 @@ func TestDync(t *testing.T) { _ = p.Refresh(prop) }, "mock panic") - assert.Equal(t, p.ObjectsCount(), 1) + assert.That(t, p.ObjectsCount()).Equal(1) }) t.Run("refresh field", func(t *testing.T) { p := New(conf.New()) - assert.Equal(t, p.ObjectsCount(), 0) + assert.That(t, p.ObjectsCount()).Equal(0) prop := conf.Map(map[string]interface{}{ "config.s1.value": "99", }) err := p.Refresh(prop) assert.Nil(t, err) - assert.Equal(t, p.Data(), prop) + assert.That(t, p.Data()).Equal(prop) var v int err = p.RefreshField(reflect.ValueOf(&v), conf.BindParam{Key: "config.s1.value"}) assert.Nil(t, err) - assert.Equal(t, v, 99) - assert.Equal(t, p.ObjectsCount(), 0) + assert.That(t, v).Equal(99) + assert.That(t, p.ObjectsCount()).Equal(0) var cfg struct { S1 struct { @@ -137,9 +137,9 @@ func TestDync(t *testing.T) { err = p.RefreshField(reflect.ValueOf(&cfg), conf.BindParam{Key: "config"}) assert.Nil(t, err) - assert.Equal(t, p.ObjectsCount(), 2) - assert.Equal(t, cfg.S1.Value.Value(), 99) - assert.Equal(t, cfg.S2.Value.Value(), 123) + assert.That(t, p.ObjectsCount()).Equal(2) + assert.That(t, cfg.S1.Value.Value()).Equal(99) + assert.That(t, cfg.S2.Value.Value()).Equal(123) prop = conf.Map(map[string]interface{}{ "config.s1.value": "99", @@ -147,9 +147,9 @@ func TestDync(t *testing.T) { "config.s4.value": "123", }) err = p.Refresh(prop) - assert.Equal(t, p.ObjectsCount(), 2) - assert.Equal(t, cfg.S1.Value.Value(), 99) - assert.Equal(t, cfg.S2.Value.Value(), 456) + assert.That(t, p.ObjectsCount()).Equal(2) + assert.That(t, cfg.S1.Value.Value()).Equal(99) + assert.That(t, cfg.S2.Value.Value()).Equal(456) prop = conf.Map(map[string]interface{}{ "config.s1.value": "99", @@ -157,9 +157,9 @@ func TestDync(t *testing.T) { "config.s3.value": "xyz", }) err = p.Refresh(prop) - assert.Equal(t, p.ObjectsCount(), 2) - assert.Equal(t, cfg.S1.Value.Value(), 99) - assert.Equal(t, cfg.S2.Value.Value(), 456) + assert.That(t, p.ObjectsCount()).Equal(2) + assert.That(t, cfg.S1.Value.Value()).Equal(99) + assert.That(t, cfg.S2.Value.Value()).Equal(456) prop = conf.Map(map[string]interface{}{ "config.s1.value": "xyz", @@ -167,18 +167,18 @@ func TestDync(t *testing.T) { "config.s3.value": "xyz", }) err = p.Refresh(prop) - assert.Error(t, err, "strconv.ParseInt: parsing \"xyz\": invalid syntax") - assert.Error(t, err, "strconv.ParseInt: parsing \"abc\": invalid syntax") + assert.ThatError(t, err).Matches("strconv.ParseInt: parsing \"xyz\": invalid syntax") + assert.ThatError(t, err).Matches("strconv.ParseInt: parsing \"abc\": invalid syntax") s1 := &Value[string]{} err = p.RefreshField(reflect.ValueOf(s1), conf.BindParam{Key: "config.s3.value"}) assert.Nil(t, err) - assert.Equal(t, s1.Value(), "xyz") - assert.Equal(t, p.ObjectsCount(), 3) + assert.That(t, s1.Value()).Equal("xyz") + assert.That(t, p.ObjectsCount()).Equal(3) s2 := &Value[int]{} err = p.RefreshField(reflect.ValueOf(s2), conf.BindParam{Key: "config.s3.value"}) - assert.Error(t, err, "strconv.ParseInt: parsing \\\"xyz\\\": invalid syntax") - assert.Equal(t, p.ObjectsCount(), 4) + assert.ThatError(t, err).Matches("strconv.ParseInt: parsing \\\"xyz\\\": invalid syntax") + assert.That(t, p.ObjectsCount()).Equal(4) }) } diff --git a/gs/internal/gs_util/util_test.go b/gs/internal/gs_util/util_test.go index dc595b81..5b954e5c 100644 --- a/gs/internal/gs_util/util_test.go +++ b/gs/internal/gs_util/util_test.go @@ -30,7 +30,7 @@ func TestTripleSort(t *testing.T) { sorting := list.New() sorted, err := TripleSort(sorting, nil) assert.Nil(t, err) - assert.Equal(t, sorted.Len(), 0) + assert.That(t, sorted.Len()).Equal(0) }) t.Run("single element", func(t *testing.T) { @@ -40,8 +40,8 @@ func TestTripleSort(t *testing.T) { sorting := util.ListOf("A") sorted, err := TripleSort(sorting, getBefore) assert.Nil(t, err) - assert.Equal(t, sorted.Len(), 1) - assert.Equal(t, sorted.Front().Value, "A") + assert.That(t, sorted.Len()).Equal(1) + assert.That(t, sorted.Front().Value).Equal("A") }) t.Run("independent elements", func(t *testing.T) { @@ -52,7 +52,7 @@ func TestTripleSort(t *testing.T) { sorting := util.ListOf("A", "B", "C") sorted, err := TripleSort(sorting, getBefore) assert.Nil(t, err) - assert.Equal(t, util.AllOfList[string](sorted), []string{"A", "B", "C"}) + assert.That(t, util.AllOfList[string](sorted)).Equal([]string{"A", "B", "C"}) }) t.Run("linear dependency", func(t *testing.T) { @@ -70,7 +70,7 @@ func TestTripleSort(t *testing.T) { sorting := util.ListOf("A", "B", "C") sorted, err := TripleSort(sorting, getBefore) assert.Nil(t, err) - assert.Equal(t, util.AllOfList[string](sorted), []string{"C", "B", "A"}) + assert.That(t, util.AllOfList[string](sorted)).Equal([]string{"C", "B", "A"}) }) t.Run("multiple dependencies", func(t *testing.T) { @@ -89,7 +89,7 @@ func TestTripleSort(t *testing.T) { sorting := util.ListOf("A", "B", "C") sorted, err := TripleSort(sorting, getBefore) assert.Nil(t, err) - assert.Equal(t, util.AllOfList[string](sorted), []string{"C", "B", "A"}) + assert.That(t, util.AllOfList[string](sorted)).Equal([]string{"C", "B", "A"}) }) t.Run("cycle", func(t *testing.T) { @@ -108,6 +108,6 @@ func TestTripleSort(t *testing.T) { } sorting := util.ListOf("A", "B", "C") _, err := TripleSort(sorting, getBefore) - assert.Error(t, err, "found sorting cycle") + assert.ThatError(t, err).Matches("found sorting cycle") }) } diff --git a/gs/prop.go b/gs/prop.go index 6803c9b9..85d167d7 100644 --- a/gs/prop.go +++ b/gs/prop.go @@ -20,7 +20,6 @@ import ( "strconv" "github.com/go-spring/spring-core/util/sysconf" - "github.com/go-spring/spring-core/util/syslog" ) const ( @@ -33,43 +32,37 @@ const ( EnableSimplePProfServerProp = "spring.enable.simple-pprof-server" ) -func setProperty(key string, val string) { - if err := sysconf.Set(key, val); err != nil { - syslog.Errorf("failed to set %s: %v", key, err) - } -} - // AllowCircularReferences enables or disables circular references between beans. func AllowCircularReferences(enable bool) { - setProperty(AllowCircularReferencesProp, strconv.FormatBool(enable)) + sysconf.Set(AllowCircularReferencesProp, strconv.FormatBool(enable)) } // ForceAutowireIsNullable forces autowire to be nullable. func ForceAutowireIsNullable(enable bool) { - setProperty(ForceAutowireIsNullableProp, strconv.FormatBool(enable)) + sysconf.Set(ForceAutowireIsNullableProp, strconv.FormatBool(enable)) } // SetActiveProfiles sets the active profiles for the app. func SetActiveProfiles(profiles string) { - setProperty(ActiveProfilesProp, profiles) + sysconf.Set(ActiveProfilesProp, profiles) } // EnableJobs enables or disables the app jobs. func EnableJobs(enable bool) { - setProperty(EnableJobsProp, strconv.FormatBool(enable)) + sysconf.Set(EnableJobsProp, strconv.FormatBool(enable)) } // EnableServers enables or disables the app servers. func EnableServers(enable bool) { - setProperty(EnableServersProp, strconv.FormatBool(enable)) + sysconf.Set(EnableServersProp, strconv.FormatBool(enable)) } // EnableSimpleHttpServer enables or disables the simple HTTP server. func EnableSimpleHttpServer(enable bool) { - setProperty(EnableSimpleHttpServerProp, strconv.FormatBool(enable)) + sysconf.Set(EnableSimpleHttpServerProp, strconv.FormatBool(enable)) } // EnableSimplePProfServer enables or disables the simple pprof server. func EnableSimplePProfServer(enable bool) { - setProperty(EnableSimplePProfServerProp, strconv.FormatBool(enable)) + sysconf.Set(EnableSimplePProfServerProp, strconv.FormatBool(enable)) } diff --git a/util/errutil/errutil.go b/util/errutil/errutil.go index c6cb1cb6..5fea76db 100644 --- a/util/errutil/errutil.go +++ b/util/errutil/errutil.go @@ -26,5 +26,5 @@ var LineBreak = " << " // WrapError wraps an existing error, creating a new error with hierarchical relationships. func WrapError(err error, format string, args ...interface{}) error { msg := fmt.Sprintf(format, args...) - return fmt.Errorf("%s%s%w", msg, LineBreak, err) + return fmt.Errorf("%s"+LineBreak+"%w", msg, err) } diff --git a/util/errutil/errutil_test.go b/util/errutil/errutil_test.go index d0cd6712..257bdeea 100644 --- a/util/errutil/errutil_test.go +++ b/util/errutil/errutil_test.go @@ -31,12 +31,12 @@ func TestWrapError(t *testing.T) { err = errutil.WrapError(err, "open file error: file=%s", "test.php") err = errutil.WrapError(err, "read file error") assert.NotNil(t, err) - assert.Equal(t, err.Error(), `read file error << open file error: file=test.php << file does not exist`) + assert.That(t, err.Error()).Equal(`read file error << open file error: file=test.php << file does not exist`) errutil.LineBreak = " / " err = os.ErrNotExist err = errutil.WrapError(err, "open file error: file=%s", "test.php") err = errutil.WrapError(err, "read file error") assert.NotNil(t, err) - assert.Equal(t, err.Error(), `read file error / open file error: file=test.php / file does not exist`) + assert.That(t, err.Error()).Equal(`read file error / open file error: file=test.php / file does not exist`) } diff --git a/util/flat.go b/util/flat.go index 11b62f48..782e5ce0 100644 --- a/util/flat.go +++ b/util/flat.go @@ -46,9 +46,10 @@ func FlattenValue(key string, val interface{}, result map[string]string) { result[key] = "" return } - for _, k := range v.MapKeys() { - mapKey := cast.ToString(k.Interface()) - mapValue := v.MapIndex(k).Interface() + iter := v.MapRange() + for iter.Next() { + mapKey := cast.ToString(iter.Key().Interface()) + mapValue := iter.Value().Interface() FlattenValue(key+"."+mapKey, mapValue, result) } case reflect.Array, reflect.Slice: diff --git a/util/flat_test.go b/util/flat_test.go index 29cb4b83..9f710d89 100644 --- a/util/flat_test.go +++ b/util/flat_test.go @@ -84,5 +84,5 @@ func TestFlatten(t *testing.T) { "arr[6]": "", "arr[7]": "", } - assert.Equal(t, m, expect) + assert.That(t, m).Equal(expect) } diff --git a/util/goutil/goutil.go b/util/goutil/goutil.go index 44d75dca..4ae1c5cd 100644 --- a/util/goutil/goutil.go +++ b/util/goutil/goutil.go @@ -14,6 +14,16 @@ * limitations under the License. */ +/* +Package goutil provides a safe way to execute goroutines with built-in panic recovery. + +In practice, goroutines may panic due to issues like nil pointer dereference or out-of-bounds access. +However, these panics can be recovered. This package offers a wrapper to safely run goroutines, +ensuring that any panic is caught and passed to a user-defined `OnPanic` handler. + +The `OnPanic` function allows developers to log the panic, report metrics, or perform other +custom recovery logic, making it easier to manage and observe unexpected failures in concurrent code. +*/ package goutil import ( diff --git a/util/goutil/goutil_test.go b/util/goutil/goutil_test.go index a59c65e1..92a57cad 100644 --- a/util/goutil/goutil_test.go +++ b/util/goutil/goutil_test.go @@ -31,12 +31,12 @@ func TestGo(t *testing.T) { goutil.Go(t.Context(), func(ctx context.Context) { panic("something is wrong") }).Wait() - assert.Equal(t, s, "") + assert.That(t, s).Equal("") goutil.Go(t.Context(), func(ctx context.Context) { s = "hello world!" }).Wait() - assert.Equal(t, s, "hello world!") + assert.That(t, s).Equal("hello world!") } func TestGoFunc(t *testing.T) { @@ -45,12 +45,12 @@ func TestGoFunc(t *testing.T) { goutil.GoFunc(func() { panic("something is wrong") }).Wait() - assert.Equal(t, s, "") + assert.That(t, s).Equal("") goutil.GoFunc(func() { s = "hello world!" }).Wait() - assert.Equal(t, s, "hello world!") + assert.That(t, s).Equal("hello world!") } func TestGoValue(t *testing.T) { @@ -58,13 +58,13 @@ func TestGoValue(t *testing.T) { s, err := goutil.GoValue(t.Context(), func(ctx context.Context) (string, error) { panic("something is wrong") }).Wait() - assert.Equal(t, s, "") - assert.Equal(t, err, fmt.Errorf("panic occurred")) + assert.That(t, s).Equal("") + assert.That(t, err).Equal(fmt.Errorf("panic occurred")) s, err = goutil.GoValue(t.Context(), func(ctx context.Context) (string, error) { return "hello world!", nil }).Wait() - assert.Equal(t, s, "hello world!") + assert.That(t, s).Equal("hello world!") assert.Nil(t, err) var arr []*goutil.ValueStatus[int] @@ -77,7 +77,7 @@ func TestGoValue(t *testing.T) { var v int for i, g := range arr { v, err = g.Wait() - assert.Equal(t, v, i) + assert.That(t, v).Equal(i) assert.Nil(t, err) } } diff --git a/util/iterutil/iterutil.go b/util/iterutil/iterutil.go deleted file mode 100644 index 4cfcef6f..00000000 --- a/util/iterutil/iterutil.go +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright 2025 The Go-Spring Authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package iterutil - -// Times executes the function 'fn' exactly 'count' times. -// Be sure to maintain the callback style. -func Times(count int, fn func(i int)) { - for i := 0; i < count; i++ { - fn(i) - } -} - -// Ranges iterates from 'start' to 'end' (exclusive) and applies 'fn' to each index. -// Be sure to maintain the callback style. -func Ranges(start, end int, fn func(i int)) { - if start < end { - stepRangesForward(start, end, 1, fn) - } else { - stepRangesBackward(start, end, -1, fn) - } -} - -// StepRanges iterates from 'start' to 'end' using a step size and applies 'fn' to each index. -// Be sure to maintain the callback style. -func StepRanges(start, end, step int, fn func(i int)) { - if step > 0 && start < end { - stepRangesForward(start, end, step, fn) - } else if step < 0 && start > end { - stepRangesBackward(start, end, step, fn) - } -} - -// stepRangesForward helper function for forward step iteration. -func stepRangesForward(start, end, step int, fn func(i int)) { - for i := start; i < end; i += step { - fn(i) - } -} - -// stepRangesBackward helper function for backward step iteration. -func stepRangesBackward(start, end, step int, fn func(i int)) { - for i := start; i > end; i += step { - fn(i) - } -} diff --git a/util/iterutil/iterutil_test.go b/util/iterutil/iterutil_test.go deleted file mode 100644 index 9274fb52..00000000 --- a/util/iterutil/iterutil_test.go +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright 2025 The Go-Spring Authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package iterutil_test - -import ( - "testing" - - "github.com/go-spring/spring-core/util/iterutil" - "github.com/lvan100/go-assert" -) - -func TestTimes(t *testing.T) { - var arr []int - iterutil.Times(5, func(i int) { - arr = append(arr, i) - }) - assert.Equal(t, arr, []int{0, 1, 2, 3, 4}) -} - -func TestRanges(t *testing.T) { - var arr []int - iterutil.Ranges(1, 5, func(i int) { - arr = append(arr, i) - }) - assert.Equal(t, arr, []int{1, 2, 3, 4}) - arr = nil - iterutil.Ranges(5, 1, func(i int) { - arr = append(arr, i) - }) - assert.Equal(t, arr, []int{5, 4, 3, 2}) -} - -func TestStepRanges(t *testing.T) { - var arr []int - iterutil.StepRanges(1, 5, 2, func(i int) { - arr = append(arr, i) - }) - assert.Equal(t, arr, []int{1, 3}) - arr = nil - iterutil.StepRanges(5, 1, -2, func(i int) { - arr = append(arr, i) - }) - assert.Equal(t, arr, []int{5, 3}) -} diff --git a/util/list_test.go b/util/list_test.go index 09371666..f0f71364 100644 --- a/util/list_test.go +++ b/util/list_test.go @@ -28,5 +28,5 @@ func TestListOf(t *testing.T) { l := util.ListOf[string]() assert.Nil(t, util.AllOfList[string](l)) l = util.ListOf("a", "b", "c") - assert.Equal(t, []string{"a", "b", "c"}, util.AllOfList[string](l)) + assert.That(t, []string{"a", "b", "c"}).Equal(util.AllOfList[string](l)) } diff --git a/util/map_test.go b/util/map_test.go index c69f1070..3fdede0c 100644 --- a/util/map_test.go +++ b/util/map_test.go @@ -67,8 +67,8 @@ func BenchmarkOrderedMapKeys(b *testing.B) { } func TestOrderedMapKeys(t *testing.T) { - assert.Equal(t, util.OrderedMapKeys(map[string]int{}), []string{}) - assert.Equal(t, util.OrderedMapKeys(map[string]int{"a": 1, "b": 2}), []string{"a", "b"}) - assert.Equal(t, util.OrderedMapKeys(map[int]string{}), []int{}) - assert.Equal(t, util.OrderedMapKeys(map[int]string{1: "a", 2: "b"}), []int{1, 2}) + assert.That(t, util.OrderedMapKeys(map[string]int{})).Equal([]string{}) + assert.That(t, util.OrderedMapKeys(map[string]int{"a": 1, "b": 2})).Equal([]string{"a", "b"}) + assert.That(t, util.OrderedMapKeys(map[int]string{})).Equal([]int{}) + assert.That(t, util.OrderedMapKeys(map[int]string{1: "a", 2: "b"})).Equal([]int{1, 2}) } diff --git a/util/sysconf/sysconf.go b/util/sysconf/sysconf.go index 21a0f9c3..1512897e 100644 --- a/util/sysconf/sysconf.go +++ b/util/sysconf/sysconf.go @@ -14,12 +14,26 @@ * limitations under the License. */ +/* +Package sysconf provides a unified configuration container for the Go programming language. + +In the Go programming language, unlike many other languages, +the standard library lacks a unified and general-purpose configuration container. +To address this gap, go-spring introduces a powerful configuration system that supports +layered configuration management and flexible injection. + +So sysconf serves as the fallback configuration container within an application, +acting as the lowest-level foundation of the configuration system. +It can be used independently or as a lightweight alternative or supplement to other +configuration sources such as environment variables, command-line arguments, or configuration files. +*/ package sysconf import ( "sync" "github.com/go-spring/spring-core/conf" + "github.com/go-spring/spring-core/util/syslog" ) var ( @@ -42,10 +56,12 @@ func Get(key string) string { } // Set sets the property of the key. -func Set(key string, val string) error { +func Set(key string, val string) { lock.Lock() defer lock.Unlock() - return prop.Set(key, val) + if err := prop.Set(key, val); err != nil { + syslog.Errorf("failed to set property key=%s, err=%v", key, err) + } } // Clear clears all properties. diff --git a/util/sysconf/sysconf_test.go b/util/sysconf/sysconf_test.go index 3ca4a9d7..6fb39bf2 100644 --- a/util/sysconf/sysconf_test.go +++ b/util/sysconf/sysconf_test.go @@ -26,17 +26,15 @@ import ( func TestSysConf(t *testing.T) { assert.False(t, sysconf.Has("name")) - err := sysconf.Set("name", "Alice") - assert.Nil(t, err) + sysconf.Set("name", "Alice") assert.True(t, sysconf.Has("name")) - assert.Equal(t, "Alice", sysconf.Get("name")) + assert.That(t, "Alice").Equal(sysconf.Get("name")) sysconf.Clear() assert.False(t, sysconf.Has("name")) - err = sysconf.Set("name", "Alice") - assert.Nil(t, err) + sysconf.Set("name", "Alice") p := sysconf.Clone() - assert.Equal(t, p.Data(), map[string]string{"name": "Alice"}) + assert.That(t, p.Data()).Equal(map[string]string{"name": "Alice"}) } diff --git a/util/syslog/syslog.go b/util/syslog/syslog.go index 616d4934..a3cfdc31 100644 --- a/util/syslog/syslog.go +++ b/util/syslog/syslog.go @@ -14,6 +14,12 @@ * limitations under the License. */ +/* +Package syslog provides simplified logging utilities for tracking the execution flow +of the go-spring framework. It is designed to offer a more convenient interface than +the standard library's slog package, whose Info, Warn, and related methods can be +cumbersome to use. Logs produced by this package are typically output to the console. +*/ package syslog import ( diff --git a/util/type.go b/util/type.go index fbd32705..edee1e57 100644 --- a/util/type.go +++ b/util/type.go @@ -21,7 +21,7 @@ import ( ) // errorType is the [reflect.Type] of the error interface. -var errorType = reflect.TypeOf((*error)(nil)).Elem() +var errorType = reflect.TypeFor[error]() // IsFuncType returns true if the provided type t is a function type. func IsFuncType(t reflect.Type) bool { diff --git a/util/type_test.go b/util/type_test.go index 0245b663..d1eecfb0 100644 --- a/util/type_test.go +++ b/util/type_test.go @@ -63,35 +63,35 @@ func TestIsPropBindingTarget(t *testing.T) { i interface{} v bool }{ - {true, true}, // Bool - {int(1), true}, // Int - {int8(1), true}, // Int8 - {int16(1), true}, // Int16 - {int32(1), true}, // Int32 - {int64(1), true}, // Int64 - {uint(1), true}, // Uint - {uint8(1), true}, // Uint8 - {uint16(1), true}, // Uint16 - {uint32(1), true}, // Uint32 - {uint64(1), true}, // Uint64 - {uintptr(0), false}, // Uintptr - {float32(1), true}, // Float32 - {float64(1), true}, // Float64 - {complex64(1), false}, // Complex64 - {complex128(1), false}, // Complex128 - {[1]int{0}, true}, // Array - {make(chan struct{}), false}, // Chan - {func() {}, false}, // Func - {reflect.TypeOf((*error)(nil)).Elem(), false}, // Interface - {make(map[int]int), true}, // Map - {make(map[string]*int), false}, // - {new(int), false}, // Ptr - {new(struct{}), false}, // - {[]int{0}, true}, // Slice - {[]*int{}, false}, // - {"this is a string", true}, // String - {struct{}{}, true}, // Struct - {unsafe.Pointer(new(int)), false}, // UnsafePointer + {true, true}, // Bool + {int(1), true}, // Int + {int8(1), true}, // Int8 + {int16(1), true}, // Int16 + {int32(1), true}, // Int32 + {int64(1), true}, // Int64 + {uint(1), true}, // Uint + {uint8(1), true}, // Uint8 + {uint16(1), true}, // Uint16 + {uint32(1), true}, // Uint32 + {uint64(1), true}, // Uint64 + {uintptr(0), false}, // Uintptr + {float32(1), true}, // Float32 + {float64(1), true}, // Float64 + {complex64(1), false}, // Complex64 + {complex128(1), false}, // Complex128 + {[1]int{0}, true}, // Array + {make(chan struct{}), false}, // Chan + {func() {}, false}, // Func + {reflect.TypeFor[error](), false}, // Interface + {make(map[int]int), true}, // Map + {make(map[string]*int), false}, // + {new(int), false}, // Ptr + {new(struct{}), false}, // + {[]int{0}, true}, // Slice + {[]*int{}, false}, // + {"this is a string", true}, // String + {struct{}{}, true}, // Struct + {unsafe.Pointer(new(int)), false}, // UnsafePointer } for _, d := range data { var typ reflect.Type @@ -112,35 +112,35 @@ func TestIsBeanType(t *testing.T) { i interface{} v bool }{ - {true, false}, // Bool - {int(1), false}, // Int - {int8(1), false}, // Int8 - {int16(1), false}, // Int16 - {int32(1), false}, // Int32 - {int64(1), false}, // Int64 - {uint(1), false}, // Uint - {uint8(1), false}, // Uint8 - {uint16(1), false}, // Uint16 - {uint32(1), false}, // Uint32 - {uint64(1), false}, // Uint64 - {uintptr(0), false}, // Uintptr - {float32(1), false}, // Float32 - {float64(1), false}, // Float64 - {complex64(1), false}, // Complex64 - {complex128(1), false}, // Complex128 - {[1]int{0}, false}, // Array - {make(chan struct{}), true}, // Chan - {func() {}, true}, // Func - {reflect.TypeOf((*error)(nil)).Elem(), true}, // Interface - {make(map[int]int), false}, // Map - {make(map[string]*int), false}, // - {new(int), false}, // - {new(struct{}), true}, // - {[]int{0}, false}, // Slice - {[]*int{}, false}, // - {"this is a string", false}, // String - {struct{}{}, false}, // Struct - {unsafe.Pointer(new(int)), false}, // UnsafePointer + {true, false}, // Bool + {int(1), false}, // Int + {int8(1), false}, // Int8 + {int16(1), false}, // Int16 + {int32(1), false}, // Int32 + {int64(1), false}, // Int64 + {uint(1), false}, // Uint + {uint8(1), false}, // Uint8 + {uint16(1), false}, // Uint16 + {uint32(1), false}, // Uint32 + {uint64(1), false}, // Uint64 + {uintptr(0), false}, // Uintptr + {float32(1), false}, // Float32 + {float64(1), false}, // Float64 + {complex64(1), false}, // Complex64 + {complex128(1), false}, // Complex128 + {[1]int{0}, false}, // Array + {make(chan struct{}), true}, // Chan + {func() {}, true}, // Func + {reflect.TypeFor[error](), true}, // Interface + {make(map[int]int), false}, // Map + {make(map[string]*int), false}, // + {new(int), false}, // + {new(struct{}), true}, // + {[]int{0}, false}, // Slice + {[]*int{}, false}, // + {"this is a string", false}, // String + {struct{}{}, false}, // Struct + {unsafe.Pointer(new(int)), false}, // UnsafePointer } for _, d := range data { var typ reflect.Type diff --git a/util/value_test.go b/util/value_test.go index 4ac8060f..c13fa8a9 100644 --- a/util/value_test.go +++ b/util/value_test.go @@ -37,12 +37,12 @@ func TestPatchValue(t *testing.T) { } func TestFuncName(t *testing.T) { - assert.Equal(t, util.FuncName(func() {}), "util_test.TestFuncName.func1") - assert.Equal(t, util.FuncName(func(i int) {}), "util_test.TestFuncName.func2") - assert.Equal(t, util.FuncName(fnNoArgs), "util_test.fnNoArgs") - assert.Equal(t, util.FuncName(fnWithArgs), "util_test.fnWithArgs") - assert.Equal(t, util.FuncName((*receiver).ptrFnNoArgs), "util_test.(*receiver).ptrFnNoArgs") - assert.Equal(t, util.FuncName((*receiver).ptrFnWithArgs), "util_test.(*receiver).ptrFnWithArgs") + assert.That(t, util.FuncName(func() {})).Equal("util_test.TestFuncName.func1") + assert.That(t, util.FuncName(func(i int) {})).Equal("util_test.TestFuncName.func2") + assert.That(t, util.FuncName(fnNoArgs)).Equal("util_test.fnNoArgs") + assert.That(t, util.FuncName(fnWithArgs)).Equal("util_test.fnWithArgs") + assert.That(t, util.FuncName((*receiver).ptrFnNoArgs)).Equal("util_test.(*receiver).ptrFnNoArgs") + assert.That(t, util.FuncName((*receiver).ptrFnWithArgs)).Equal("util_test.(*receiver).ptrFnWithArgs") } func fnNoArgs() {} @@ -89,8 +89,8 @@ func TestFileLine(t *testing.T) { } for i, c := range testcases { file, line, fnName := util.FileLine(c.fn) - assert.Equal(t, line, c.line, fmt.Sprint(i)) - assert.Equal(t, fnName, c.fnName, fmt.Sprint(i)) - assert.String(t, file).HasSuffix(c.file, fmt.Sprint(i)) + assert.That(t, line).Equal(c.line, fmt.Sprint(i)) + assert.That(t, fnName).Equal(c.fnName, fmt.Sprint(i)) + assert.ThatString(t, file).HasSuffix(c.file, fmt.Sprint(i)) } }