Function TestCounterInt64_RemoteRollbackCallback

data/shared_state_variable_test.go:1269–1469

TestCounterInt64_RemoteRollbackCallback tests that large rollback callbacks are triggered via remote updates (processNewState) when the rollback is APPLIED.

(t *testing.T)

// TestCounterInt64_RemoteRollbackCallback tests that large rollback callbacks are triggered
// via remote updates (processNewState) when the rollback is APPLIED.
func TestCounterInt64_RemoteRollbackCallback(t *testing.T) {
	t.Run("large rollback applied and callback fires on remote update", func(t *testing.T) {
		counter := &counterInt64{
			ignoreRollbackOf: 100, // Ignore rollbacks <= 100
			registry: &sharedStateRegistry{
				logger:     &log.Logger,
				instanceId: "test",
			},
		}
		counter.value.Store(10000)
		counter.updatedAtUnixMs.Store(1)

		var callbackMu sync.Mutex
		var callbackCalls []struct{ current, new int64 }
		counter.OnLargeRollback(func(currentVal, newVal int64) {
			callbackMu.Lock()
			callbackCalls = append(callbackCalls, struct{ current, new int64 }{currentVal, newVal})
			callbackMu.Unlock()
		})

		// Remote update with large rollback (gap=5000 > ignoreRollbackOf=100)
		updated := counter.processNewState(UpdateSourceRemoteSync, CounterInt64State{
			Value:     5000, // 5000 blocks rollback
			UpdatedAt: 2,    // Fresher timestamp
			UpdatedBy: "remote-instance",
		})

		// Value SHOULD be rolled back (large rollback is applied)
		assert.True(t, updated)
		assert.Equal(t, int64(5000), counter.GetValue())

		// And callback SHOULD have been triggered
		callbackMu.Lock()
		defer callbackMu.Unlock()
		assert.Len(t, callbackCalls, 1, "rollback callback should fire on remote large rollback")
		if len(callbackCalls) > 0 {
			assert.Equal(t, int64(10000), callbackCalls[0].current)
			assert.Equal(t, int64(5000), callbackCalls[0].new)
		}
	})

	t.Run("small rollback ignored and callback does NOT fire", func(t *testing.T) {
		counter := &counterInt64{
			ignoreRollbackOf: 100, // Ignore rollbacks <= 100
			registry: &sharedStateRegistry{
				logger:     &log.Logger,
				instanceId: "test",
			},
		}
		counter.value.Store(10000)
		counter.updatedAtUnixMs.Store(1)

		var callbackCalls []struct{ current, new int64 }
		counter.OnLargeRollback(func(currentVal, newVal int64) {
			callbackCalls = append(callbackCalls, struct{ current, new int64 }{currentVal, newVal})
		})

		// Remote update with small rollback (gap=50 <= ignoreRollbackOf=100)