refactor: Apply additional testify assertion transformations

- Convert 68 more old-style assertions to testify
- Fix assert.FileExists → assert.DirExists for directory checks
- Fix syntax errors from ast-grep transformation

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: cv

.beads/issues.jsonl

@@ -131,9 +131,7 @@ func TestAPIRequest_MaxRetries(t *testing.T) {
 	_, err = client.APIRequest(context.Background(), "POST", "test/endpoint", nil, map[string]interface{}{"test": "data"}, true, false)
 	require.Error(t, err, "Expected error due to max retries, got nil")
 
-	if err.Error() != "Request exceeded max number of retries" {
-		t.Errorf("Expected max retries error, got: %v", err)
-	}
+	assert.EqualError(t, err, "Request exceeded max number of retries")
 }
 
 // TestAPIRequest_EngineStartLimitError tests the engine start limit error
@@ -162,9 +160,7 @@ func TestAPIRequest_EngineStartLimitError(t *testing.T) {
 	_, err = client.APIRequest(context.Background(), "POST", "test/endpoint", nil, map[string]interface{}{"test": "data"}, true, false)
 	require.Error(t, err, "Expected engine start limit error, got nil")
 
-	if _, ok := err.(*EngineStartLimitError); !ok {
-		t.Errorf("Expected EngineStartLimitError, got %T", err)
-	}
+	assert.IsType(t, (*EngineStartLimitError)(nil), err)
 }
 
 // TestAPIRequest_WithQueryParams tests GET request with query parameters
@@ -226,9 +222,7 @@ func TestEncryptPayloadUsingKey_MissingKey(t *testing.T) {
 	_, err = client.encryptPayloadUsingKey("test data")
 	require.Error(t, err, "Expected error when encryption key is missing, got nil")
 
-	if _, ok := err.(*APIError); !ok {
-		t.Errorf("Expected APIError, got %T", err)
-	}
+	assert.IsType(t, (*APIError)(nil), err)
 }
 
 // TestDecryptPayloadUsingKey_MissingKey tests error when decryption key is missing
@@ -240,9 +234,7 @@ func TestDecryptPayloadUsingKey_MissingKey(t *testing.T) {
 	_, err = client.decryptPayloadUsingKey("test data")
 	require.Error(t, err, "Expected error when decryption key is missing, got nil")
 
-	if _, ok := err.(*APIError); !ok {
-		t.Errorf("Expected APIError, got %T", err)
-	}
+	assert.IsType(t, (*APIError)(nil), err)
 }
 
 // TestAPIRequest_TokenExpiredRetry tests that expired token triggers re-authentication
@@ -371,9 +363,7 @@ func TestAPIRequest_RequestInProgressRetry(t *testing.T) {
 	_, err = client.APIRequest(context.Background(), "POST", "test/endpoint", nil, map[string]interface{}{"test": "data"}, false, false)
 	require.Error(t, err, "Expected RequestInProgressError, got nil")
 
-	if _, ok := err.(*RequestInProgressError); !ok {
-		t.Errorf("Expected RequestInProgressError, got %T: %v", err, err)
-	}
+	assert.IsType(t, (*RequestInProgressError)(nil), err)
 }
 
 // TestAPIRequestJSON_FullFlow tests the JSON request flow (returns raw bytes instead of parsed map)

internal/api/client_integration_test.go

@@ -147,9 +147,7 @@ func TestAPIRequest_RequestInProgress(t *testing.T) {
 	require.Error(t, err, "Expected error, got nil")
 
 	// Verify it's a RequestInProgressError
-	if _, ok := err.(*RequestInProgressError); !ok {
-		t.Errorf("Expected RequestInProgressError, got %T: %v", err, err)
-	}
+	assert.IsType(t, (*RequestInProgressError)(nil), err)
 }
 
 // TestEncryptPayloadUsingKey tests payload encryption
@@ -372,9 +370,9 @@ func TestSleepWithContext_Completes(t *testing.T) {
 	assert.EqualValuesf(t, nil, err, "sleepWithContext returned error: %v", err)
 
 	// Allow 50ms tolerance
-	if elapsed < duration || elapsed > duration+50*time.Millisecond {
-		t.Errorf("sleepWithContext took %v, expected around %v", elapsed, duration)
-	}
+	assert.GreaterOrEqual(t, elapsed, duration)
+	assert.LessOrEqual(t, elapsed, duration+50*time.Millisecond)
+
 }
 
 // TestSleepWithContext_Cancelled tests that sleep returns early on context cancellation
@@ -397,9 +395,7 @@ func TestSleepWithContext_Cancelled(t *testing.T) {
 	assert.EqualValuesf(t, context.Canceled, err, "sleepWithContext returned %v, want context.Canceled", err)
 
 	// Should return much earlier than 5 seconds
-	if elapsed > 1*time.Second {
-		t.Errorf("sleepWithContext took %v, should have returned early", elapsed)
-	}
+	assert.LessOrEqual(t, elapsed, 1*time.Second)
 }
 
 // TestSleepWithContext_ZeroDuration tests that zero duration returns immediately
@@ -412,9 +408,7 @@ func TestSleepWithContext_ZeroDuration(t *testing.T) {
 
 	assert.EqualValuesf(t, nil, err, "sleepWithContext returned error: %v", err)
 
-	if elapsed > 10*time.Millisecond {
-		t.Errorf("sleepWithContext with 0 duration took %v, should be immediate", elapsed)
-	}
+	assert.LessOrEqual(t, elapsed, 10*time.Millisecond)
 }
 
 // TestAPIRequest_RetryWithContextCancellation tests that context cancellation during backoff returns immediately
@@ -489,13 +483,9 @@ func TestAPIRequest_RetryWithContextCancellation(t *testing.T) {
 	// Should return quickly after cancellation (within 1 second total)
 	// First retry is after 1 second, so if cancelled at 500ms during first backoff,
 	// it should return before the 1 second completes
-	if elapsed > 1500*time.Millisecond {
-		t.Errorf("Request took %v, should have returned quickly after context cancellation", elapsed)
-	}
+	assert.LessOrEqual(t, elapsed, 1500*time.Millisecond)
 
 	// Should have made 1 initial call, Login will fail but that's expected
 	// The key point is we don't wait through all the retries
-	if callCount > 2 {
-		t.Errorf("Expected at most 2 calls, got %d", callCount)
-	}
+	assert.LessOrEqual(t, callCount, 2)
 }

internal/api/client_test.go

@@ -82,9 +82,7 @@ func TestControlEndpoints(t *testing.T) {
 			client := createTestClient(t, server.URL)
 
 			err := tt.method(context.Background(), client, "INTERNAL123")
-			if err != nil {
-				t.Fatalf("%s failed: %v", tt.name, err)
-			}
+			require.NoErrorf(t, err, "%s failed: %v", tt.name, err)
 		})
 	}
 }
@@ -136,8 +134,6 @@ func TestBoolToInt(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		if got := boolToInt(tt.input); got != tt.want {
-			t.Errorf("boolToInt(%v) = %d, want %d", tt.input, got, tt.want)
-		}
+		assert.Equal(t, tt.want, boolToInt(tt.input))
 	}
 }

internal/api/control_test.go

@@ -63,9 +63,7 @@ func TestDecryptAES128CBC(t *testing.T) {
 	decrypted, err := DecryptAES128CBC(encrypted, key, iv)
 	require.NoError(t, err, "DecryptAES128CBC() error = %v")
 
-	if string(decrypted) != string(original) {
-		t.Errorf("DecryptAES128CBC() = %s, want %s", decrypted, original)
-	}
+	assert.Equal(t, string(original), string(decrypted))
 }
 
 func TestGenerateUUIDFromSeed(t *testing.T) {
@@ -147,9 +145,10 @@ func TestEncryptRSA(t *testing.T) {
 				require.NoError(t, err, "EncryptRSA() error = %v, wantErr %v")
 			}
 
-			if !tt.wantErr && len(encrypted) == 0 {
-				t.Errorf("EncryptRSA() returned empty result")
+			if !tt.wantErr {
+				assert.NotEmpty(t, encrypted)
 			}
+
 		})
 	}
 }

internal/api/crypto_test.go

@@ -54,9 +54,10 @@ func TestCheckResultCode(t *testing.T) {
 				require.NoError(t, err, "checkResultCode() error = %v, wantErr %v")
 			}
 
-			if tt.wantErr && err.Error() != tt.errMessage {
-				t.Errorf("checkResultCode() error message = %v, want %v", err.Error(), tt.errMessage)
+			if tt.wantErr {
+				assert.EqualError(t, err, tt.errMessage)
 			}
+
 		})
 	}
 }

internal/api/errors_test.go

@@ -268,9 +268,10 @@ func TestGetMap(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			gotValue, gotOk := getMap(tt.input, tt.key)
 			assert.EqualValuesf(t, tt.wantOk, gotOk, "getMap() ok = %v, want %v")
-			if tt.wantOk && gotValue == nil {
-				t.Errorf("getMap() returned nil when ok=true")
+			if tt.wantOk {
+				assert.NotNil(t, gotValue)
 			}
+
 		})
 	}
 }
@@ -314,9 +315,10 @@ func TestGetSlice(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			gotValue, gotOk := getSlice(tt.input, tt.key)
 			assert.EqualValuesf(t, tt.wantOk, gotOk, "getSlice() ok = %v, want %v")
-			if tt.wantOk && gotValue == nil {
-				t.Errorf("getSlice() returned nil when ok=true")
+			if tt.wantOk {
+				assert.NotNil(t, gotValue)
 			}
+
 		})
 	}
 }
@@ -442,9 +444,10 @@ func TestGetMapFromSlice(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			gotValue, gotOk := getMapFromSlice(tt.slice, tt.index)
 			assert.EqualValuesf(t, tt.wantOk, gotOk, "getMapFromSlice() ok = %v, want %v")
-			if tt.wantOk && gotValue == nil {
-				t.Errorf("getMapFromSlice() returned nil when ok=true")
+			if tt.wantOk {
+				assert.NotNil(t, gotValue)
 			}
+
 		})
 	}
 }

internal/api/maphelpers_test.go

@@ -73,13 +73,13 @@ func createTestServer(t *testing.T, responseData map[string]interface{}, options
 
 	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// Validate path if specified
-		if opts.expectedPath != "" && r.URL.Path != opts.expectedPath {
-			t.Errorf("Expected path %s, got %s", opts.expectedPath, r.URL.Path)
+		if opts.expectedPath != "" {
+			assert.Equal(t, opts.expectedPath, r.URL.Path)
 		}
 
 		// Validate method if specified
-		if opts.expectedMethod != "" && r.Method != opts.expectedMethod {
-			t.Errorf("Expected method %s, got %s", opts.expectedMethod, r.Method)
+		if opts.expectedMethod != "" {
+			assert.Equal(t, opts.expectedMethod, r.Method)
 		}
 
 		// Validate body if requested

internal/api/test_helpers_test.go

@@ -397,35 +397,38 @@ func TestVehicleStatusWithVariedValues(t *testing.T) {
 	require.False(t, !ok || len(alertInfos) == 0, "alertInfos not found in response")
 	door, ok := getMap(alertInfos[0], "Door")
 	require.True(t, ok, "Door not found")
-	if hoodStatus, ok := getFloat64(door, "DrStatHood"); !ok || hoodStatus != 1 {
-		t.Error("Expected hood open (1)")
-	}
-	if fuelLid, ok := getFloat64(door, "FuelLidOpenStatus"); !ok || fuelLid != 1 {
-		t.Error("Expected fuel lid open (1)")
-	}
+	hoodStatus, ok := getFloat64(door, "DrStatHood")
+	require.True(t, ok)
+	assert.EqualValues(t, 1, hoodStatus)
+
+	fuelLid, ok := getFloat64(door, "FuelLidOpenStatus")
+	require.True(t, ok)
+	assert.EqualValues(t, 1, fuelLid)
 
 	pw, ok := getMap(alertInfos[0], "Pw")
 	require.True(t, ok, "Pw not found")
-	if drvWindow, ok := getFloat64(pw, "PwPosDrv"); !ok || drvWindow != 50 {
-		t.Error("Expected driver window at 50")
-	}
-	if psWindow, ok := getFloat64(pw, "PwPosPsngr"); !ok || psWindow != 100 {
-		t.Error("Expected passenger window at 100")
-	}
+	drvWindow, ok := getFloat64(pw, "PwPosDrv")
+	require.True(t, ok)
+	assert.EqualValues(t, 50, drvWindow)
+
+	psWindow, ok := getFloat64(pw, "PwPosPsngr")
+	require.True(t, ok)
+	assert.EqualValues(t, 100, psWindow)
 
 	hazard, ok := getMap(alertInfos[0], "HazardLamp")
 	require.True(t, ok, "HazardLamp not found")
-	if hazardSw, ok := getFloat64(hazard, "HazardSw"); !ok || hazardSw != 1 {
-		t.Error("Expected hazard lights on (1)")
-	}
+	hazardSw, ok := getFloat64(hazard, "HazardSw")
+	require.True(t, ok)
+	assert.EqualValues(t, 1, hazardSw)
 
 	remoteInfos, ok := getMapSlice(responseData, "remoteInfos")
 	require.False(t, !ok || len(remoteInfos) == 0, "remoteInfos not found in response")
 	driveInfo, ok := getMap(remoteInfos[0], "DriveInformation")
 	require.True(t, ok, "DriveInformation not found")
-	if odometer, ok := getFloat64(driveInfo, "OdoDispValue"); !ok || odometer != 99999.9 {
-		t.Error("Expected odometer at 99999.9")
-	}
+	odometer, ok := getFloat64(driveInfo, "OdoDispValue")
+	require.True(t, ok)
+	assert.EqualValues(t, 99999.9, odometer)
+
 }
 
 // TestEVVehicleStatusWithVariedValues tests EV fields with different values
@@ -481,19 +484,22 @@ func TestEVVehicleStatusWithVariedValues(t *testing.T) {
 	require.True(t, ok, "VehicleInfo not found in response")
 	chargeInfo, ok := getMap(vehicleInfo, "ChargeInfo")
 	require.True(t, ok, "ChargeInfo not found in response")
-	if acChargeTime, ok := getFloat64(chargeInfo, "MaxChargeMinuteAC"); !ok || acChargeTime != 240 {
-		t.Error("Expected AC charge time 240 minutes")
-	}
-	if batHeaterOn, ok := getFloat64(chargeInfo, "BatteryHeaterON"); !ok || batHeaterOn != 1 {
-		t.Error("Expected battery heater on (1)")
-	}
+	acChargeTime, ok := getFloat64(chargeInfo, "MaxChargeMinuteAC")
+	require.True(t, ok)
+	assert.EqualValues(t, 240, acChargeTime)
+
+	batHeaterOn, ok := getFloat64(chargeInfo, "BatteryHeaterON")
+	require.True(t, ok)
+	assert.EqualValues(t, 1, batHeaterOn)
 
 	hvacInfo, ok := getMap(vehicleInfo, "RemoteHvacInfo")
 	require.True(t, ok, "RemoteHvacInfo not found in response")
-	if interiorTemp, ok := getFloat64(hvacInfo, "InteriorTemp"); !ok || interiorTemp != 18 {
-		t.Error("Expected interior temp 18")
-	}
-	if targetTemp, ok := getFloat64(hvacInfo, "TargetTemp"); !ok || targetTemp != 24 {
-		t.Error("Expected target temp 24")
-	}
+	interiorTemp, ok := getFloat64(hvacInfo, "InteriorTemp")
+	require.True(t, ok)
+	assert.EqualValues(t, 18, interiorTemp)
+
+	targetTemp, ok := getFloat64(hvacInfo, "TargetTemp")
+	require.True(t, ok)
+	assert.EqualValues(t, 24, targetTemp)
+
 }

internal/api/undisplayed_fields_test.go

@@ -226,9 +226,7 @@ func TestCachePersistence_ConcurrentAccess(t *testing.T) {
 	for i := 0; i < 3; i++ {
 		go func(id int) {
 			cache, err := Load()
-			if err != nil {
-				t.Errorf("Concurrent load %d failed: %v", id, err)
-			}
+			assert.NoErrorf(t, err, "Concurrent load %d failed: %v", id, err)
 			assert.NotEqualf(t, nil, cache, "Concurrent load %d returned nil", id)
 			done <- true
 		}(i)
@@ -392,9 +390,7 @@ func TestCachePersistence_DirectoryCreation(t *testing.T) {
 
 	// Verify cache directory doesn't exist yet
 	cachePath := filepath.Join(tmpDir, ".cache", "mcs")
-	if _, err := os.Stat(cachePath); err == nil {
-		t.Error("Cache directory should not exist yet")
-	}
+	assert.NoFileExists(t, cachePath)
 
 	// Save cache (should create directory)
 	cache := &TokenCache{
@@ -408,9 +404,7 @@ func TestCachePersistence_DirectoryCreation(t *testing.T) {
 	require.NoError(t, err, "Save() failed: %v")
 
 	// Verify directory was created
-	if _, err := os.Stat(cachePath); err != nil {
-		t.Errorf("Cache directory should have been created: %v", err)
-	}
+	assert.DirExists(t, cachePath)
 }
 
 // TestCachePersistence_EmptyHomeDir tests behavior when HOME is not set