Remove deprecated info parameter

Signed-off-by: apostasie <[email protected]>

Author: apostasie

mod/tigron/expect/comparators.go

@@ -30,19 +30,19 @@ import (
 
 // All can be used as a parameter for expected.Output to group a set of comparators.
 func All(comparators ...test.Comparator) test.Comparator {
-	return func(stdout, _ string, t *testing.T) {
+	return func(stdout string, t *testing.T) {
 		t.Helper()
 
 		for _, comparator := range comparators {
-			comparator(stdout, "", t)
+			comparator(stdout, t)
 		}
 	}
 }
 
 // Contains can be used as a parameter for expected.Output and ensures a comparison string is found contained in the
 // output.
 func Contains(compare string, more ...string) test.Comparator {
-	return func(stdout, _ string, t *testing.T) {
+	return func(stdout string, t *testing.T) {
 		t.Helper()
 
 		assertive.Contains(assertive.WithFailLater(t), stdout, compare, "Inspecting output (contains)")
@@ -55,7 +55,7 @@ func Contains(compare string, more ...string) test.Comparator {
 
 // DoesNotContain is to be used for expected.Output to ensure a comparison string is NOT found in the output.
 func DoesNotContain(compare string, more ...string) test.Comparator {
-	return func(stdout, _ string, t *testing.T) {
+	return func(stdout string, t *testing.T) {
 		t.Helper()
 
 		assertive.DoesNotContain(assertive.WithFailLater(t), stdout, compare, "Inspecting output (does not contain)")
@@ -68,31 +68,31 @@ func DoesNotContain(compare string, more ...string) test.Comparator {
 
 // Equals is to be used for expected.Output to ensure it is exactly the output.
 func Equals(compare string) test.Comparator {
-	return func(stdout, _ string, t *testing.T) {
+	return func(stdout string, t *testing.T) {
 		t.Helper()
 		assertive.IsEqual(assertive.WithFailLater(t), stdout, compare, "Inspecting output (equals)")
 	}
 }
 
 // Match is to be used for expected.Output to ensure we match a regexp.
 func Match(reg *regexp.Regexp) test.Comparator {
-	return func(stdout, _ string, t *testing.T) {
+	return func(stdout string, t *testing.T) {
 		t.Helper()
 		assertive.Match(assertive.WithFailLater(t), stdout, reg, "Inspecting output (match)")
 	}
 }
 
 // JSON allows to verify that the output can be marshalled into T, and optionally can be further verified by a provided
 // method.
-func JSON[T any](obj T, verifier func(T, string, tig.T)) test.Comparator {
-	return func(stdout, _ string, t *testing.T) {
+func JSON[T any](obj T, verifier func(T, tig.T)) test.Comparator {
+	return func(stdout string, t *testing.T) {
 		t.Helper()
 
 		err := json.Unmarshal([]byte(stdout), &obj)
 		assertive.ErrorIsNil(assertive.WithSilentSuccess(t), err, "Unmarshalling JSON from stdout must succeed")
 
 		if verifier != nil && err == nil {
-			verifier(obj, "Inspecting output (JSON)", t)
+			verifier(obj, t)
 		}
 	}
 }

mod/tigron/expect/comparators_test.go

@@ -33,10 +33,10 @@ func TestExpect(t *testing.T) {
 	// TODO: write more tests once we can mock t in Comparator signature
 	t.Parallel()
 
-	expect.Contains("b")("a b c", "contains works", t)
-	expect.DoesNotContain("d")("a b c", "does not contain works", t)
-	expect.Equals("a b c")("a b c", "equals work", t)
-	expect.Match(regexp.MustCompile("[a-z ]+"))("a b c", "match works", t)
+	expect.Contains("b")("a b c", t)
+	expect.DoesNotContain("d")("a b c", t)
+	expect.Equals("a b c")("a b c", t)
+	expect.Match(regexp.MustCompile("[a-z ]+"))("a b c", t)
 
 	expect.All(
 		expect.Contains("b"),
@@ -45,7 +45,7 @@ func TestExpect(t *testing.T) {
 		expect.DoesNotContain("d", "e"),
 		expect.Equals("a b c"),
 		expect.Match(regexp.MustCompile("[a-z ]+")),
-	)("a b c", "all", t)
+	)("a b c", t)
 
 	type foo struct {
 		Foo map[string]string `json:"foo"`
@@ -59,9 +59,9 @@ func TestExpect(t *testing.T) {
 
 	assertive.ErrorIsNil(t, err)
 
-	expect.JSON(&foo{}, nil)(string(data), "json, no verifier", t)
+	expect.JSON(&foo{}, nil)(string(data), t)
 
-	expect.JSON(&foo{}, func(obj *foo, info string, t tig.T) {
-		assertive.IsEqual(t, obj.Foo["foo"], "bar", info)
-	})(string(data), "json, with verifier", t)
+	expect.JSON(&foo{}, func(obj *foo, t tig.T) {
+		assertive.IsEqual(t, obj.Foo["foo"], "bar")
+	})(string(data), t)
 }

mod/tigron/expect/doc.md

@@ -58,7 +58,7 @@ The following ready-made `test.Comparator` generators are provided:
 - `expect.Equals(string)`: strict equality
 - `expect.Match(*regexp.Regexp)`: regexp matching
 - `expect.All(comparators ...Comparator)`: allows to bundle together a bunch of other comparators
-- `expect.JSON[T any](obj T, verifier func(T, string, tig.T))`: allows to verify the output is valid JSON and optionally
+- `expect.JSON[T any](obj T, verifier func(T, tig.T))`: allows to verify the output is valid JSON and optionally
 pass `verifier(T, string, tig.T)` extra validation
 
 ### A complete example
@@ -93,8 +93,8 @@ func TestMyThing(t *testing.T) {
         expect.All(
             expect.Contains("out"),
             expect.DoesNotContain("something"),
-            expect.JSON(&Thing{}, func(obj *Thing, info string, t tig.T) {
-                assert.Equal(t, obj.Name, "something", info)
+            expect.JSON(&Thing{}, func(obj *Thing, t tig.T) {
+                assert.Equal(t, obj.Name, "something")
             }),
         ),
     )
@@ -206,11 +206,11 @@ func TestMyThing(t *testing.T) {
             Errors: []error{
                 errors.New("foobla"),
             },
-            Output: func(stdout, info string, t tig.T) {
+            Output: func(stdout string, t tig.T) {
                 t.Helper()
 
                 // Retrieve the data that was set during the Setup phase.
-                assert.Assert(t, stdout == data.Labels().Get("sometestdata"), info)
+                assert.Assert(t, stdout == data.Labels().Get("sometestdata"))
             },
         }
     }

mod/tigron/test/command.go

@@ -294,7 +294,6 @@ func (gc *GenericCommand) Run(expect *Expected) {
 		if expect.Output != nil {
 			expect.Output(
 				result.Stdout,
-				"",
 				gc.t,
 			)
 		}

mod/tigron/test/funct.go

@@ -30,7 +30,7 @@ type Butler func(data Data, helpers Helpers)
 // - move to tig.T
 
 // A Comparator is the function signature to implement for the Output property of an Expected.
-type Comparator func(stdout, info string, t *testing.T)
+type Comparator func(stdout string, t *testing.T)
 
 // A Manager is the function signature meant to produce expectations for a command.
 type Manager func(data Data, helpers Helpers) *Expected

mod/tigron/test/helpers.go

@@ -61,7 +61,7 @@ func (help *helpersInternal) Capture(args ...string) string {
 	help.t.Helper()
 	help.Command(args...).Run(&Expected{
 		//nolint:thelper
-		Output: func(stdout, _ string, _ *testing.T) {
+		Output: func(stdout string, _ *testing.T) {
 			ret = stdout
 		},
 	})