Function TestCounterInt64_EarliestBlockSemantics

data/shared_state_variable_test.go:1201–1265

TestCounterInt64_EarliestBlockSemantics tests that earliest block counters (ignoreRollbackOf=0) correctly accept decreases, which is needed when detection finds an earlier available block.

(t *testing.T)

// TestCounterInt64_EarliestBlockSemantics tests that earliest block counters (ignoreRollbackOf=0)
// correctly accept decreases, which is needed when detection finds an earlier available block.
func TestCounterInt64_EarliestBlockSemantics(t *testing.T) {
	t.Run("earliest block accepts decrease via local update (processNewValue)", func(t *testing.T) {
		counter := &counterInt64{
			ignoreRollbackOf: 0, // earliest block mode: accept all rollbacks
			registry: &sharedStateRegistry{
				logger: &log.Logger,
			},
		}
		counter.value.Store(1500) // Initial earliest block

		// Simulate detection that earliest is actually lower (e.g., re-detection found earlier block)
		// This is a DECREASE: 1500 → 1000
		updated := counter.processNewValue(UpdateSourceTryUpdate, 1000)
		assert.True(t, updated, "should accept decrease with ignoreRollbackOf=0")
		assert.Equal(t, int64(1000), counter.GetValue())

		// Also accepts increases (forward progress due to pruning)
		updated = counter.processNewValue(UpdateSourceTryUpdate, 2000)
		assert.True(t, updated, "should also accept increases")
		assert.Equal(t, int64(2000), counter.GetValue())
	})

	t.Run("earliest block accepts decrease via remote update (processNewState)", func(t *testing.T) {
		counter := &counterInt64{
			ignoreRollbackOf: 0, // earliest block mode: accept all rollbacks
			registry: &sharedStateRegistry{
				logger:     &log.Logger,
				instanceId: "test",
			},
		}
		counter.value.Store(1500)
		counter.updatedAtUnixMs.Store(1)

		// Remote update with fresher timestamp and lower value
		// This is a DECREASE: 1500 → 1000
		updated := counter.processNewState(UpdateSourceRemoteSync, CounterInt64State{
			Value:     1000, // Decrease from 1500
			UpdatedAt: 2,    // Fresher timestamp
			UpdatedBy: "remote-instance",
		})
		assert.True(t, updated, "should accept decrease with ignoreRollbackOf=0 via remote")
		assert.Equal(t, int64(1000), counter.GetValue())
	})

	t.Run("earliest block remote decrease rejected if timestamp is stale", func(t *testing.T) {
		counter := &counterInt64{
			ignoreRollbackOf: 0, // earliest block mode
			registry: &sharedStateRegistry{
				logger:     &log.Logger,
				instanceId: "test",
			},
		}
		counter.value.Store(1000)
		counter.updatedAtUnixMs.Store(10) // Local has timestamp 10

		// Remote update with STALE timestamp (should be rejected regardless of value)
		updated := counter.processNewState(UpdateSourceRemoteSync, CounterInt64State{
			Value:     500, // Even though it's a valid decrease