test(account,feature): make UpdatedAt assertions falsifiable

In account_test.go the InDelta assertions could not fail: NewAccountV2
and the setup AddSearchFilter calls already stamp UpdatedAt with the
current time, so removing the stamp from the mutator under test still
passed. Backdate UpdatedAt before the call and branch on whether the
mutator is expected to stamp it, which also covers the error paths
leaving the field untouched.

In TestChangeRulesOrder the expected value was captured once before the
loop over a shared, mutated feature, so the assertion only held because
the stamping case happened to be last. Read the previous value inside
the loop instead.

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

Author: s35560

pkg/account/domain/account_test.go

@@ -25,6 +25,11 @@ import (
 	"github.com/bucketeer-io/bucketeer/v2/proto/common"
 )
 
+func backdateUpdatedAt(a *AccountV2) int64 {
+	a.UpdatedAt = time.Now().Add(-time.Hour).Unix()
+	return a.UpdatedAt
+}
+
 func TestNewMemberAccount(t *testing.T) {
 	envRoles := []*proto.AccountV2_EnvironmentRole{
 		{
@@ -460,6 +465,7 @@ func TestAddSearchFilter(t *testing.T) {
 				[]string{"team"},
 				account.OrganizationId,
 				account.OrganizationRole, account.EnvironmentRoles)
+			backdatedUpdatedAt := backdateUpdatedAt(a)
 			for _, f := range p.expectedFilters {
 				_, err := a.AddSearchFilter(f.Name, f.Query, f.FilterTargetType, f.EnvironmentId, f.DefaultFilter)
 				assert.Nil(t, err)
@@ -474,7 +480,11 @@ func TestAddSearchFilter(t *testing.T) {
 			assert.Equal(t, account.OrganizationId, a.OrganizationId)
 			assert.Equal(t, account.OrganizationRole, a.OrganizationRole)
 			assert.Equal(t, account.EnvironmentRoles, a.EnvironmentRoles)
-			assert.InDelta(t, time.Now().Unix(), a.UpdatedAt, 5)
+			if len(p.expectedFilters) > 0 {
+				assert.InDelta(t, time.Now().Unix(), a.UpdatedAt, 5)
+			} else {
+				assert.Equal(t, backdatedUpdatedAt, a.UpdatedAt)
+			}
 
 			assert.Equal(t, len(p.expectedFilters), len(a.SearchFilters))
 			for i, f := range p.expectedFilters {
@@ -627,6 +637,7 @@ func TestChangeSearchFilterName(t *testing.T) {
 			if len(a.SearchFilters) > 0 {
 				updateFilterId = a.SearchFilters[(len(a.SearchFilters) / 2)].Id
 			}
+			backdatedUpdatedAt := backdateUpdatedAt(a)
 			err := a.ChangeSearchFilterName(updateFilterId, p.updateFilterName)
 			assert.Equal(t, err, p.error)
 
@@ -640,7 +651,11 @@ func TestChangeSearchFilterName(t *testing.T) {
 			assert.Equal(t, account.OrganizationId, a.OrganizationId)
 			assert.Equal(t, account.OrganizationRole, a.OrganizationRole)
 			assert.Equal(t, account.EnvironmentRoles, a.EnvironmentRoles)
-			assert.InDelta(t, time.Now().Unix(), a.UpdatedAt, 5)
+			if p.error == nil {
+				assert.InDelta(t, time.Now().Unix(), a.UpdatedAt, 5)
+			} else {
+				assert.Equal(t, backdatedUpdatedAt, a.UpdatedAt)
+			}
 
 			assert.Equal(t, len(p.expectedFilters), len(a.SearchFilters))
 			for i, f := range p.expectedFilters {
@@ -781,6 +796,7 @@ func TestChangeSearchFilterQuery(t *testing.T) {
 			if len(a.SearchFilters) > 0 {
 				updateFilterId = a.SearchFilters[(len(a.SearchFilters) / 2)].Id
 			}
+			backdatedUpdatedAt := backdateUpdatedAt(a)
 			err := a.ChangeSearchFilterQuery(updateFilterId, p.updateFilterQuery)
 			assert.Equal(t, err, p.error)
 
@@ -794,7 +810,11 @@ func TestChangeSearchFilterQuery(t *testing.T) {
 			assert.Equal(t, account.OrganizationId, a.OrganizationId)
 			assert.Equal(t, account.OrganizationRole, a.OrganizationRole)
 			assert.Equal(t, account.EnvironmentRoles, a.EnvironmentRoles)
-			assert.InDelta(t, time.Now().Unix(), a.UpdatedAt, 5)
+			if p.error == nil {
+				assert.InDelta(t, time.Now().Unix(), a.UpdatedAt, 5)
+			} else {
+				assert.Equal(t, backdatedUpdatedAt, a.UpdatedAt)
+			}
 
 			assert.Equal(t, len(p.expectedFilters), len(a.SearchFilters))
 			for i, f := range p.expectedFilters {
@@ -939,6 +959,7 @@ func TestChangeDefaultSearchFilter(t *testing.T) {
 				Id:            updateFilterId,
 				DefaultFilter: p.updateDefaultFilter,
 			}
+			backdatedUpdatedAt := backdateUpdatedAt(a)
 			err := a.ChangeDefaultSearchFilter(
 				updateFilter.Id,
 				updateFilter.DefaultFilter)
@@ -954,7 +975,11 @@ func TestChangeDefaultSearchFilter(t *testing.T) {
 			assert.Equal(t, account.OrganizationId, a.OrganizationId)
 			assert.Equal(t, account.OrganizationRole, a.OrganizationRole)
 			assert.Equal(t, account.EnvironmentRoles, a.EnvironmentRoles)
-			assert.InDelta(t, time.Now().Unix(), a.UpdatedAt, 5)
+			if p.error == nil {
+				assert.InDelta(t, time.Now().Unix(), a.UpdatedAt, 5)
+			} else {
+				assert.Equal(t, backdatedUpdatedAt, a.UpdatedAt)
+			}
 
 			assert.Equal(t, len(p.expectedFilters), len(a.SearchFilters))
 			for i, f := range p.expectedFilters {
@@ -1076,6 +1101,7 @@ func TestDeleteSearchFilter(t *testing.T) {
 			if len(a.SearchFilters) > 0 {
 				deleteFilterId = a.SearchFilters[(len(a.SearchFilters) / 2)].Id
 			}
+			backdatedUpdatedAt := backdateUpdatedAt(a)
 			err := a.DeleteSearchFilter(deleteFilterId)
 			assert.Equal(t, err, p.error)
 
@@ -1089,7 +1115,11 @@ func TestDeleteSearchFilter(t *testing.T) {
 			assert.Equal(t, account.OrganizationId, a.OrganizationId)
 			assert.Equal(t, account.OrganizationRole, a.OrganizationRole)
 			assert.Equal(t, account.EnvironmentRoles, a.EnvironmentRoles)
-			assert.InDelta(t, time.Now().Unix(), a.UpdatedAt, 5)
+			if p.error == nil {
+				assert.InDelta(t, time.Now().Unix(), a.UpdatedAt, 5)
+			} else {
+				assert.Equal(t, backdatedUpdatedAt, a.UpdatedAt)
+			}
 
 			assert.Equal(t, len(p.expectedFilters), len(a.SearchFilters))
 			if len(a.SearchFilters) > 0 {

pkg/feature/domain/feature_test.go

@@ -785,7 +785,6 @@ func TestChangeRuleStrategyToFixed(t *testing.T) {
 func TestChangeRulesOrder(t *testing.T) {
 	t.Helper()
 	f := makeFeature("test-feature")
-	initialUpdatedAt := f.UpdatedAt
 	patterns := []*struct {
 		ruleIDs            []string
 		expected           []string
@@ -815,12 +814,13 @@ func TestChangeRulesOrder(t *testing.T) {
 		},
 	}
 	for _, p := range patterns {
+		updatedAtBefore := f.UpdatedAt
 		err := f.ChangeRulesOrder(p.ruleIDs)
 		assert.Equal(t, p.expectedError, err)
 		if p.expectUpdatedAtNow {
 			assert.InDelta(t, time.Now().Unix(), f.UpdatedAt, 5)
 		} else {
-			assert.Equal(t, initialUpdatedAt, f.UpdatedAt)
+			assert.Equal(t, updatedAtBefore, f.UpdatedAt)
 		}
 		for i := range f.Rules {
 			if p.expected[i] != f.Rules[i].Id {