Migrate tests to testify (#487)

## Summary
- migrate test assertions to testify / patterns across the suite
- fix migration regressions by restoring test semantics where assertions
were over-rewritten
- keep matcher strictness pragmatic ( where numeric type differences are
expected)

Author: mariusvniekerk

.golangci.yml

@@ -9,6 +9,7 @@ linters:
     - ineffassign
     - modernize
     - staticcheck
+    - testifylint
     - unused
   settings:
     errcheck:

AGENTS.md

@@ -153,6 +153,15 @@ Test conventions:
 - PostgreSQL-only tests use `//go:build postgres`.
 - ACP adapter integration tests use `//go:build integration && acp`.
 - Shared helpers live in `internal/testenv/`, `internal/testutil/`, and package-local `*_test_helpers*.go`.
+- In tests with more than three assertions, prefer `assert := assert.New(t)` to make grouped assertions cleaner.
+- Avoid `assert.False*` / `require.False*` and do not use `assert.Fail`/`require.Fail` in tests.
+- Prefer `assert.Equal` for explicit expectations and avoid `assert.True*` / `require.True*` unless checking a boolean result directly.
+- Convert redundant `if` wrappers around assertions into direct assertions (for example, `if err != nil { require.NoError(t, err) }` should become `require.NoError(t, err)`).
+- Do not replace assertions with manual control-flow (`if`, `t.Fatal*`, `t.Error*`) when a direct testify check covers the same condition.
+- Enforce a no-redundant-guards policy for assertions:
+  - replace `if err != nil { require.NoError(t, err, ...) }` and `if err == nil { ... } else { ... }` with direct `require.Error`/`require.NoError`/`require.NotNil` statements.
+  - avoid manual `if` prechecks such as `if got != want` or `if cfg != nil`; convert to direct `assert.Equal`/`assert.NotNil` assertions.
+  - remove `assert`/`require` fail helpers and `t.Fatal`/`t.Fatalf`/`t.Error` usage when a direct assertion provides the same check.
 
 ## Search Shortcuts
 

cmd/roborev/analyze_integration_test.go

@@ -6,13 +6,14 @@ import (
 	"context"
 	"net/http"
 	"regexp"
-	"strings"
 	"sync/atomic"
 	"testing"
 	"time"
 
 	"github.com/roborev-dev/roborev/internal/prompt/analyze"
 	"github.com/roborev-dev/roborev/internal/storage"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestWaitForAnalysisJob(t *testing.T) {
@@ -97,24 +98,14 @@ func TestWaitForAnalysisJob(t *testing.T) {
 			review, err := waitForAnalysisJob(ctx, ts.URL, testJobID)
 
 			if tt.wantErr {
-				if err == nil {
-					t.Fatal("expected error, got nil")
-				}
-				if !strings.Contains(err.Error(), tt.wantErrMsg) {
-					t.Errorf("error %q should contain %q", err.Error(), tt.wantErrMsg)
-				}
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErrMsg)
 				return
 			}
 
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if review == nil {
-				t.Fatal("expected review, got nil")
-			}
-			if review.Output != tt.wantReview {
-				t.Errorf("got review %q, want %q", review.Output, tt.wantReview)
-			}
+			require.NoError(t, err)
+			require.NotNil(t, review, "expected review, got nil")
+			assert.Equal(t, tt.wantReview, review.Output)
 		})
 	}
 }
@@ -142,27 +133,15 @@ func TestRunAnalyzeAndFix_Integration(t *testing.T) {
 	}
 
 	err := runAnalyzeAndFix(cmd, ts.URL, repo.Dir, 99, analysisType, opts)
-	if err != nil {
-		t.Fatalf("runAnalyzeAndFix failed: %v", err)
-	}
+	require.NoError(t, err, "runAnalyzeAndFix failed: %v")
 
 	// Verify the workflow was executed
-	if atomic.LoadInt32(&state.JobsCount) < 2 {
-		t.Error("should have polled for job status")
-	}
-	if atomic.LoadInt32(&state.ReviewCount) == 0 {
-		t.Error("should have fetched the review")
-	}
-	if atomic.LoadInt32(&state.CloseCount) == 0 {
-		t.Error("should have marked job as closed")
-	}
+	assert.GreaterOrEqual(t, atomic.LoadInt32(&state.JobsCount), int32(2))
+	assert.NotZero(t, atomic.LoadInt32(&state.ReviewCount))
+	assert.NotZero(t, atomic.LoadInt32(&state.CloseCount))
 
 	// Verify output contains analysis result
 	outputStr := output.String()
-	if !strings.Contains(outputStr, "CODE SMELLS") {
-		t.Error("output should contain analysis result")
-	}
-	if !regexp.MustCompile(`Analysis job \d+ closed`).MatchString(outputStr) {
-		t.Errorf("output should match 'Analysis job N closed', got: %s", outputStr)
-	}
+	assert.Contains(t, outputStr, "CODE SMELLS")
+	assert.Regexp(t, regexp.MustCompile(`Analysis job \d+ closed`), outputStr)
 }