chore: update dependencies and fix new lint rules

Author: krostar

assert.go

@@ -40,6 +40,7 @@ func Assert(t TestingT, result bool, msgAndArgs ...any) bool {
 	t.Helper()
 
 	logResult(t, result, 1, msgAndArgs...)
+
 	if !result {
 		t.Fail()
 	}
@@ -53,6 +54,7 @@ func Require(t TestingT, result bool, msgAndArgs ...any) {
 	t.Helper()
 
 	logResult(t, result, 1, msgAndArgs...)
+
 	if !result {
 		t.FailNow()
 	}
@@ -85,6 +87,7 @@ func logResult(t TestingT, result bool, callerStackIndex int, msgAndArgs ...any)
 
 	if (result && (SuccessMessageEnabled || *_flagEnableSuccessMessage)) || !result {
 		var err error
+
 		msg, err = message.FromBool(callerStackIndex+1, result)
 		if err != nil {
 			t.Logf("krostar/test internal failure: unable to get assertion message: %v", err)

assert_test.go

@@ -13,19 +13,22 @@ func Test_Assert(t *testing.T) {
 			if result := Assert(spiedT, true, "hello from %s", t.Name()); !result {
 				t.Error("Assert should return true when result is true")
 			}
+
 			spiedT.ExpectTestToPass(t)
 			spiedT.ExpectNoLogs(t)
 		})
 
 		t.Run("with success message enabled", func(t *testing.T) {
 			originalSuccessMessageEnabled := SuccessMessageEnabled
 			t.Cleanup(func() { SuccessMessageEnabled = originalSuccessMessageEnabled })
+
 			SuccessMessageEnabled = true
 
 			spiedT := double.NewSpy(double.NewFake())
 			if result := Assert(spiedT, true, "hello from %s", t.Name()); !result {
 				t.Error("Assert should return true when result is true")
 			}
+
 			spiedT.ExpectTestToPass(t)
 			spiedT.ExpectLogsToContain(t, "Success:", "[hello from Test_Assert/assertion_true/with_success_message_enabled]")
 		})
@@ -36,6 +39,7 @@ func Test_Assert(t *testing.T) {
 		if result := Assert(spiedT, false, "hello from %s", t.Name()); result {
 			t.Error("Assert should return false when result is false")
 		}
+
 		spiedT.ExpectTestToFail(t)
 		spiedT.ExpectLogsToContain(t, "Error:", "[hello from Test_Assert/assertion_false]")
 	})
@@ -53,6 +57,7 @@ func Test_Require(t *testing.T) {
 		t.Run("with success message enabled", func(t *testing.T) {
 			originalSuccessMessageEnabled := SuccessMessageEnabled
 			t.Cleanup(func() { SuccessMessageEnabled = originalSuccessMessageEnabled })
+
 			SuccessMessageEnabled = true
 
 			spiedT := double.NewSpy(double.NewFake())
@@ -75,6 +80,7 @@ func Test_logResult(t *testing.T) {
 	t.Run("success without message", func(t *testing.T) {
 		originalSuccessMessageEnabled := SuccessMessageEnabled
 		t.Cleanup(func() { SuccessMessageEnabled = originalSuccessMessageEnabled })
+
 		SuccessMessageEnabled = false
 
 		spiedT := double.NewSpy(double.NewFake())
@@ -85,6 +91,7 @@ func Test_logResult(t *testing.T) {
 	t.Run("success with message", func(t *testing.T) {
 		originalSuccessMessageEnabled := SuccessMessageEnabled
 		t.Cleanup(func() { SuccessMessageEnabled = originalSuccessMessageEnabled })
+
 		SuccessMessageEnabled = true
 
 		spiedT := double.NewSpy(double.NewFake())

check/check.go

@@ -52,7 +52,9 @@ func Eventually(ctx context.Context, t test.TestingT, check func(context.Context
 			} else {
 				return t, true, fmt.Sprintf("check passed in %s with %d retries", time.Since(startedAt).String(), retries)
 			}
+
 			retries++
+
 			ticker.Reset(timeBetweenRetries)
 
 		case <-ticker.C:
@@ -102,7 +104,8 @@ func Panics(t test.TestingT, f func(), assertReason func(reason any) error) (tt
 		return t, false, "function to test for panic must not be nil"
 	}
 
-	tt = t //
+	tt = t
+
 	defer func() {
 		reason := recover()
 

check/check_test.go

@@ -55,17 +55,22 @@ func Test_Compare(t *testing.T) {
 func Test_Eventually(t *testing.T) {
 	t.Run("success after retries", func(t *testing.T) {
 		retries := 0
+
 		ctx, cancel := context.WithTimeout(t.Context(), 500*time.Millisecond)
 		defer cancel()
 
 		tt, result, msg := Eventually(ctx, t, func(context.Context) error {
 			defer func() { retries++ }()
+
 			if retries < 2 {
 				return fmt.Errorf("boom %d", retries)
 			}
+
 			return nil
 		}, time.Millisecond*10)
+
 		assertCheck(t, tt, result, true, msg, "check passed")
+
 		if retries < 2 {
 			t.Errorf("expected at least 2 retries, got %d", retries)
 		}
@@ -132,6 +137,7 @@ func Test_Panics(t *testing.T) {
 			}
 			return nil
 		})
+
 		assertCheck(t, tt, result, true, msg, "function panicked like expected")
 	})
 
@@ -171,7 +177,7 @@ func assertCheck(t *testing.T, tt test.TestingT, result, expectedResult bool, ms
 	t.Helper()
 
 	if t != tt.(*testing.T) {
-		t.Errorf("expected check to return the same testingT as provided")
+		t.Error("expected check to return the same testingT as provided")
 	}
 
 	if result != expectedResult {

context.go

@@ -30,6 +30,7 @@ func Context(t TestingT) context.Context {
 		deadline = deadline.Add(-cleanDuration)
 
 		var cancel context.CancelFunc
+
 		ctx, cancel = context.WithDeadline(ctx, deadline)
 		t.Cleanup(cancel)
 	}

double/fake.go

@@ -41,6 +41,10 @@ func (Fake) Fail() {}
 // This is a no-op implementation.
 func (Fake) FailNow() {}
 
+// Log implements the TestingT interface.
+// This is a no-op implementation.
+func (Fake) Log(...any) {}
+
 // Logf implements the TestingT interface.
 // This is a no-op implementation.
 func (Fake) Logf(string, ...any) {}

double/fake_option_test.go

@@ -31,10 +31,12 @@ func Test_FakeWithRegisterCleanup(t *testing.T) {
 	called := false
 	FakeWithRegisterCleanup(func(f func()) {
 		called = true
+
 		f()
 	})(o)
 
 	o.registerCleanup(func() {})
+
 	if !called {
 		t.Error("registerCleanup was not set")
 	}

double/spy.go

@@ -77,6 +77,20 @@ func (spy *Spy) FailNow() {
 	spy.failed = true
 }
 
+// Log implements the TestingT interface.
+func (spy *Spy) Log(args ...any) {
+	spy.m.Lock()
+	defer spy.m.Unlock()
+
+	spy.underlyingT.Log(args...)
+	spy.records = append(spy.records, SpyTestingTRecord{
+		Method:  "Log",
+		Inputs:  args,
+		Outputs: nil,
+	})
+	spy.logs = append(spy.logs, fmt.Sprint(args...))
+}
+
 // Logf implements the TestingT interface.
 func (spy *Spy) Logf(format string, args ...any) {
 	spy.m.Lock()

double/spy_expect.go

@@ -111,7 +111,7 @@ func (spy *Spy) ExpectTestToFail(t TestingT) {
 	t.Helper()
 
 	if !spy.failed {
-		t.Logf("Expected test to fail but test succeeded")
+		t.Log("Expected test to fail but test succeeded")
 		t.Fail()
 	}
 }
@@ -126,7 +126,7 @@ func (spy *Spy) ExpectTestToPass(t TestingT) {
 	t.Helper()
 
 	if spy.failed {
-		t.Logf("Expected test to succeed but test failed")
+		t.Log("Expected test to succeed but test failed")
 		t.Fail()
 	}
 }

double/spy_expect_test.go

@@ -94,7 +94,6 @@ func Test_SpyTestingT_ExpectRecords(t *testing.T) {
 func Test_SpyTestingT_ExpectNoLogs(t *testing.T) {
 	testedT := NewSpy(NewFake())
 	testedT.ExpectNoLogs(t)
-
 	testedT.Logf("hello world")
 
 	spiedT := NewSpy(NewFake())
@@ -106,11 +105,13 @@ func Test_SpyTestingT_ExpectNoLogs(t *testing.T) {
 func Test_SpyTestingT_ExpectLogsToContain(t *testing.T) {
 	testedT := NewSpy(NewFake())
 	spiedT := NewSpy(NewFake())
+
 	testedT.ExpectLogsToContain(spiedT, "foo")
 	spiedT.ExpectTestToFail(t)
 	spiedT.ExpectLogsToContain(t, "Expected log to contain message")
 
 	spiedT = NewSpy(NewFake())
+
 	testedT.Logf("hello world")
 	testedT.ExpectLogsToContain(t, "hello world")
 	testedT.ExpectLogsToContain(spiedT, "foo")
@@ -125,21 +126,20 @@ func Test_SpyTestingT_ExpectLogsToContain(t *testing.T) {
 
 func Test_SpyTestingT_ExpectTestToFail(t *testing.T) {
 	testedT := NewSpy(NewFake())
-
 	spiedT := NewSpy(NewFake())
+
 	testedT.ExpectTestToFail(spiedT)
 	spiedT.ExpectTestToFail(t)
 	spiedT.ExpectLogsToContain(t, "Expected test to fail but test succeeded")
-
 	testedT.Fail()
 	testedT.ExpectTestToFail(t)
 }
 
 func Test_SpyTestingT_ExpectTestToPass(t *testing.T) {
 	testedT := NewSpy(NewFake())
 	testedT.ExpectTestToPass(t)
-
 	testedT.Fail()
+
 	spiedT := NewSpy(NewFake())
 	testedT.ExpectTestToPass(spiedT)
 	spiedT.ExpectTestToFail(t)