sync_shapes_test.go

package yin

import (
	"encoding/json"
	"testing"
)

func TestCatchUpSinceV(t *testing.T) {
	replica := ReplicaID("replica-a")

	behind := NewLWWRegister[string](replica)
	behind.Set("v1")
	since := behind.Version()

	ahead := NewLWWRegister[string](replica)
	ahead.Set("v1")
	ahead.Set("v2")

	delta := ahead.ExtractDelta(since)
	if delta == nil {
		t.Fatal("ExtractDelta(since behind version) returned nil, want catch-up delta")
	}
	if changed := behind.ApplyDelta(delta); !changed {
		t.Fatal("ApplyDelta catch-up changed = false, want true")
	}
	if !behind.Equal(ahead) {
		t.Fatalf("behind after catch-up = %#v, want ahead %#v", behind, ahead)
	}
	if got := behind.Version().Compare(since); got != VersionVectorDominates {
		t.Fatalf("behind.Version().Compare(since) = %s, want %s", got, VersionVectorDominates)
	}
}

func TestIdempotentIngest(t *testing.T) {
	source := NewLWWRegister[string](ReplicaID("replica-a"))
	source.Set("fresh")

	target := NewLWWRegister[string](ReplicaID("replica-b"))
	delta := source.ExtractDelta(target.Version())
	if delta == nil {
		t.Fatal("ExtractDelta(empty target version) returned nil, want fresh delta")
	}
	if changed := target.ApplyDelta(delta); !changed {
		t.Fatal("first ApplyDelta changed = false, want true")
	}
	if changed := target.ApplyDelta(delta); changed {
		t.Fatal("replayed ApplyDelta changed = true, want false")
	}
	if changed := source.ApplyDelta(delta); changed {
		t.Fatal("already-known ApplyDelta changed = true, want false")
	}

	older := NewLWWRegister[string](ReplicaID("replica-a"))
	older.Set("older")
	olderDelta := older.ExtractDelta(VersionVector{})
	if olderDelta == nil {
		t.Fatal("older ExtractDelta returned nil, want delta")
	}

	newer := NewLWWRegister[string](ReplicaID("replica-b"))
	newer.Set("newer-1")
	newer.Set("newer-2")
	if changed := newer.ApplyDelta(olderDelta); changed {
		t.Fatal("older ApplyDelta changed = true, want false")
	}
	assertLWWRegisterState(t, newer, "newer-2", 2, ReplicaID("replica-b"))
}

func TestFarBehindFallbackUsesLWWMapSnapshotMerge(t *testing.T) {
	sourceReplica := ReplicaID("source")
	ahead := NewLWWMap[json.RawMessage](sourceReplica)
	ahead.Set("card", json.RawMessage(`{"title":"draft"}`))
	ahead.Set("lane", json.RawMessage(`"todo"`))

	behind := NewLWWMap[json.RawMessage](ReplicaID("behind"))
	bootstrap := ahead.ExtractDelta(behind.Version())
	if bootstrap == nil {
		t.Fatal("ExtractDelta(empty behind version) returned nil, want bootstrap delta")
	}
	if changed := behind.ApplyDelta(bootstrap); !changed {
		t.Fatal("bootstrap ApplyDelta changed = false, want true")
	}

	ahead.Set("lane", json.RawMessage(`"done"`))
	ahead.Delete("card")
	ahead.Set("new-card", json.RawMessage(`{"title":"ship"}`))

	encodedSnapshot, err := MarshalLWWMapSnapshotJSON(ahead)
	if err != nil {
		t.Fatalf("MarshalLWWMapSnapshotJSON() error = %v", err)
	}
	snapshot, err := UnmarshalLWWMapSnapshotJSON(ReplicaID("snapshot-local"), encodedSnapshot)
	if err != nil {
		t.Fatalf("UnmarshalLWWMapSnapshotJSON() error = %v", err)
	}

	if changed := behind.Merge(snapshot); !changed {
		t.Fatal("Merge(decoded snapshot) changed = false, want far-behind catch-up")
	}
	if !behind.Equal(ahead) {
		t.Fatalf("behind after snapshot merge = %#v, want ahead %#v", behind, ahead)
	}
	if changed := behind.Merge(snapshot); changed {
		t.Fatal("duplicate Merge(decoded snapshot) changed = true, want false")
	}
	if delta := ahead.ExtractDelta(behind.Version()); delta != nil {
		t.Fatalf("ExtractDelta(caught-up behind version) = %#v, want nil", delta)
	}
	if got, ok := behind.Get("card"); ok || got != nil {
		t.Fatalf("Get(card) after snapshot merge = (%q, %t), want nil and false", []byte(got), ok)
	}
	assertLWWMapEntry(t, behind, "card", json.RawMessage(nil), true, 4, sourceReplica)
	assertLWWMapEntry(t, behind, "lane", json.RawMessage(`"done"`), false, 3, sourceReplica)
	assertLWWMapEntry(t, behind, "new-card", json.RawMessage(`{"title":"ship"}`), false, 5, sourceReplica)
	assertLWWMapVersion(t, behind.Version(), map[ReplicaID]uint64{sourceReplica: 5})
}

func TestRestoredSnapshotPeerResumesDeltaCatchUp(t *testing.T) {
	sourceReplica := ReplicaID("source")
	source := NewLWWMap[json.RawMessage](sourceReplica)
	source.Set("card", json.RawMessage(`{"title":"before"}`))
	source.Set("presence", json.RawMessage(`{"online":false}`))

	encodedSnapshot, err := MarshalLWWMapSnapshotJSON(source)
	if err != nil {
		t.Fatalf("MarshalLWWMapSnapshotJSON() error = %v", err)
	}
	restored, err := UnmarshalLWWMapSnapshotJSON(ReplicaID("restored-peer"), encodedSnapshot)
	if err != nil {
		t.Fatalf("UnmarshalLWWMapSnapshotJSON() error = %v", err)
	}
	if !restored.Equal(source) {
		t.Fatalf("restored snapshot = %#v, want source %#v", restored, source)
	}
	snapshotVersion := restored.Version()

	source.Set("card", json.RawMessage(`{"title":"after"}`))
	source.Delete("presence")
	source.Set("message", json.RawMessage(`{"text":"hello"}`))

	delta := source.ExtractDelta(snapshotVersion)
	if delta == nil {
		t.Fatal("ExtractDelta(restored snapshot version) returned nil, want post-snapshot delta")
	}
	codec := NewJSONLWWMapDeltaCodec[json.RawMessage]()
	encodedDelta, err := codec.EncodeDelta(delta)
	if err != nil {
		t.Fatalf("EncodeDelta() error = %v", err)
	}
	decodedDelta, err := codec.DecodeDelta(encodedDelta)
	if err != nil {
		t.Fatalf("DecodeDelta() error = %v", err)
	}

	if changed := restored.ApplyDelta(decodedDelta); !changed {
		t.Fatal("ApplyDelta(decoded post-snapshot delta) changed = false, want true")
	}
	if !restored.Equal(source) {
		t.Fatalf("restored after delta catch-up = %#v, want source %#v", restored, source)
	}
	if changed := restored.ApplyDelta(decodedDelta); changed {
		t.Fatal("duplicate ApplyDelta(decoded post-snapshot delta) changed = true, want false")
	}
	assertLWWMapEntry(t, restored, "card", json.RawMessage(`{"title":"after"}`), false, 3, sourceReplica)
	assertLWWMapEntry(t, restored, "presence", json.RawMessage(nil), true, 4, sourceReplica)
	assertLWWMapEntry(t, restored, "message", json.RawMessage(`{"text":"hello"}`), false, 5, sourceReplica)
	assertLWWMapVersion(t, restored.Version(), map[ReplicaID]uint64{sourceReplica: 5})
}