Change comparators signature to use tig.T

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

Author: apostasie

mod/tigron/expect/comparators.go

@@ -15,13 +15,12 @@
 */
 
 //revive:disable:package-comments // annoying false positive behavior
-//nolint:thelper // FIXME: remove when we move to tig.T
+
 package expect
 
 import (
 	"encoding/json"
 	"regexp"
-	"testing"
 
 	"github.com/containerd/nerdctl/mod/tigron/internal/assertive"
 	"github.com/containerd/nerdctl/mod/tigron/test"
@@ -30,7 +29,7 @@ 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 tig.T) {
 		t.Helper()
 
 		for _, comparator := range comparators {
@@ -42,41 +41,51 @@ func All(comparators ...test.Comparator) test.Comparator {
 // 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) {
-		t.Helper()
+	return func(stdout string, testing tig.T) {
+		testing.Helper()
 
-		assertive.Contains(assertive.WithFailLater(t), stdout, compare, "Inspecting output (contains)")
+		assertive.Contains(assertive.WithFailLater(testing), stdout, compare, "Inspecting output (contains)")
 
 		for _, m := range more {
-			assertive.Contains(assertive.WithFailLater(t), stdout, m, "Inspecting output (contains)")
+			assertive.Contains(assertive.WithFailLater(testing), stdout, m, "Inspecting output (contains)")
 		}
 	}
 }
 
 // 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) {
-		t.Helper()
+	return func(stdout string, testing tig.T) {
+		testing.Helper()
 
-		assertive.DoesNotContain(assertive.WithFailLater(t), stdout, compare, "Inspecting output (does not contain)")
+		assertive.DoesNotContain(
+			assertive.WithFailLater(testing),
+			stdout,
+			compare,
+			"Inspecting output (does not contain)",
+		)
 
 		for _, m := range more {
-			assertive.DoesNotContain(assertive.WithFailLater(t), stdout, m, "Inspecting output (does not contain)")
+			assertive.DoesNotContain(
+				assertive.WithFailLater(testing),
+				stdout,
+				m,
+				"Inspecting output (does not contain)",
+			)
 		}
 	}
 }
 
 // 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 tig.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 tig.T) {
 		t.Helper()
 		assertive.Match(assertive.WithFailLater(t), stdout, reg, "Inspecting output (match)")
 	}
@@ -85,14 +94,14 @@ func Match(reg *regexp.Regexp) test.Comparator {
 // 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, tig.T)) test.Comparator {
-	return func(stdout string, t *testing.T) {
-		t.Helper()
+	return func(stdout string, testing tig.T) {
+		testing.Helper()
 
 		err := json.Unmarshal([]byte(stdout), &obj)
-		assertive.ErrorIsNil(assertive.WithSilentSuccess(t), err, "Unmarshalling JSON from stdout must succeed")
+		assertive.ErrorIsNil(assertive.WithSilentSuccess(testing), err, "Unmarshalling JSON from stdout must succeed")
 
 		if verifier != nil && err == nil {
-			verifier(obj, t)
+			verifier(obj, testing)
 		}
 	}
 }

mod/tigron/test/funct.go

@@ -16,7 +16,9 @@
 
 package test
 
-import "testing"
+import (
+	"github.com/containerd/nerdctl/mod/tigron/tig"
+)
 
 // An Evaluator is a function that decides whether a test should run or not.
 type Evaluator func(data Data, helpers Helpers) (bool, string)
@@ -30,7 +32,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 string, t *testing.T)
+type Comparator func(stdout string, t tig.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

@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	"github.com/containerd/nerdctl/mod/tigron/internal"
+	"github.com/containerd/nerdctl/mod/tigron/tig"
 )
 
 // This is the implementation of Helpers
@@ -60,8 +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, _ tig.T) {
 			ret = stdout
 		},
 	})