1 files changed, 191 insertions, 0 deletions
diff --git a/internal/calendar/transfer_plan_cache_test.go b/internal/calendar/transfer_plan_cache_test.go
new file mode 100644
index 0000000..6b3b48b
--- /dev/null
+++ b/internal/calendar/transfer_plan_cache_test.go
@@ -0,0 +1,191 @@
+package calendar_test
+
+// Tests for the memoised EF transfer plan (transfer_plan_cache.go). These
+// live in the external test package (calendar_test), exercising the real
+// tridentine sanctoral data through the public Compute entry point, the same
+// style precedence_ef_repro_test.go already uses -- the risk this cache
+// introduces is entirely about whether the CACHE KEY captures every real
+// input, which can only be demonstrated by varying an input through Compute
+// and checking the observed office actually changes, not by testing the
+// cache's internals in isolation.
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/lukaszkasprzak/lectio/internal/caldata"
+	"github.com/lukaszkasprzak/lectio/internal/calendar"
+)
+
+// TestEFTransferPlanCacheInvalidatesOnOverlay is THE bad-key test: it warms
+// the memoised plan for (2008, EF, the shipped calendar) across a whole
+// week -- mobile.Days's own access pattern -- then asks the SAME year
+// through a layer stack with ONE user overlay added (suppressing the
+// Annunciation) and asserts the observed office on 31 March and 1 April
+// CHANGES accordingly.
+//
+// What is varied: the layer stack / merged sanctoral content (a user
+// overlay), holding year and Selection fixed. This is deliberately not a
+// synthetic scenario: with the Annunciation present, its RG 96(a) proper
+// seat (the Monday after Low Sunday, RG 97/98) forces St Joseph -- also
+// impeded that year -- to walk one day further, to 1 April
+// (TestEFTwoTransfersDoNotCollide already pins this). Suppress the
+// Annunciation and it no longer claims that Monday, so Joseph lands ON it,
+// 31 March, and 1 April reverts to an ordinary feria. Verified empirically
+// against the pre-cache code before this test was written (both outcomes
+// reproduced exactly as asserted below).
+//
+// A cache keyed on year alone -- or on year+sel without the merged content
+// -- would serve 2008's BASE-CALENDAR plan back for the overlaid query too,
+// since both share every other key component; this test fails loudly if
+// that happens (it would see 1 April still reporting Joseph, and 31 March
+// still reporting the Annunciation, from the first, unrelated warm-up).
+func TestEFTransferPlanCacheInvalidatesOnOverlay(t *testing.T) {
+	sel := calendar.DefaultSelection()
+	sel.Form = "old"
+	base := caldata.Tridentine()
+	baseLayers := []calendar.Layer{base}
+
+	compute := func(layers []calendar.Layer, date string) string {
+		d, err := time.Parse("2006-01-02", date)
+		if err != nil {
+			t.Fatalf("bad test date %q: %v", date, err)
+		}
+		return calendar.Compute(d.UTC(), sel, layers).Observed.Slug
+	}
+
+	// Warm the cache for (2008, sel, base-only-hash) across a whole week,
+	// exactly like mobile.Days resolving seven consecutive dates against the
+	// same Prepared layer stack.
+	for _, date := range []string{
+		"2008-03-26", "2008-03-27", "2008-03-28", "2008-03-29",
+		"2008-03-30", "2008-03-31", "2008-04-01", "2008-04-02",
+	} {
+		compute(baseLayers, date)
+	}
+	if got := compute(baseLayers, "2008-03-31"); got != "annunciation-of-the-blessed-virgin-mary" {
+		t.Fatalf("baseline 2008-03-31 = %q, want annunciation-of-the-blessed-virgin-mary", got)
+	}
+	if got := compute(baseLayers, "2008-04-01"); got != "joseph-spouse-of-the-bl-virgin-mary" {
+		t.Fatalf("baseline 2008-04-01 = %q, want joseph-spouse-of-the-bl-virgin-mary", got)
+	}
+
+	// Same year, same Selection, ONE overlay layer added: suppress the
+	// Annunciation. If the cache key omitted the sanctoral content, these
+	// two calls would silently return the baseline plan warmed above.
+	overlay := calendar.Layer{ID: "user", Cels: map[string]calendar.RawCelebration{
+		"annunciation-of-the-blessed-virgin-mary": {
+			Fields:   map[string]string{"suppress": "true"},
+			Variants: map[string]map[string]string{},
+		},
+	}}
+	overlaid := []calendar.Layer{base, overlay}
+
+	if got := compute(overlaid, "2008-03-31"); got != "joseph-spouse-of-the-bl-virgin-mary" {
+		t.Errorf("overlaid 2008-03-31 = %q, want joseph-spouse-of-the-bl-virgin-mary (Joseph now lands here, the Annunciation no longer claims it)", got)
+	}
+	if got := compute(overlaid, "2008-04-01"); got == "joseph-spouse-of-the-bl-virgin-mary" {
+		t.Errorf("overlaid 2008-04-01 = %q, want NOT joseph (a stale cache hit from the base-calendar warm-up)", got)
+	}
+
+	// And the base calendar's own answer must be unaffected by having since
+	// computed the overlaid one -- the two keys must not collide either way.
+	if got := compute(baseLayers, "2008-03-31"); got != "annunciation-of-the-blessed-virgin-mary" {
+		t.Errorf("base calendar 2008-03-31 after overlaid query = %q, want annunciation-of-the-blessed-virgin-mary (unaffected)", got)
+	}
+	if got := compute(baseLayers, "2008-04-01"); got != "joseph-spouse-of-the-bl-virgin-mary" {
+		t.Errorf("base calendar 2008-04-01 after overlaid query = %q, want joseph-spouse-of-the-bl-virgin-mary (unaffected)", got)
+	}
+}
+
+// TestEFTransferPlanCacheInvalidatesOnYear is a lighter companion: the same
+// week-then-query pattern, varying the YEAR instead of the overlay (2008 vs
+// 2035, both real Joseph/Annunciation collision years -- see
+// TestEFTwoTransfersDoNotCollide -- but with different transfer targets).
+// year is an explicit field of the cache key already, so this mainly guards
+// against a key struct refactor accidentally dropping it; the overlay test
+// above is the one guarding the field that is easy to omit by mistake.
+func TestEFTransferPlanCacheInvalidatesOnYear(t *testing.T) {
+	sel := calendar.DefaultSelection()
+	sel.Form = "old"
+	layers := []calendar.Layer{caldata.Tridentine()}
+
+	compute := func(date string) string {
+		d, err := time.Parse("2006-01-02", date)
+		if err != nil {
+			t.Fatalf("bad test date %q: %v", date, err)
+		}
+		return calendar.Compute(d.UTC(), sel, layers).Observed.Slug
+	}
+
+	if got := compute("2008-04-01"); got != "joseph-spouse-of-the-bl-virgin-mary" {
+		t.Fatalf("2008-04-01 = %q, want joseph-spouse-of-the-bl-virgin-mary", got)
+	}
+	// 2035's Joseph lands on 2035-04-03, not 04-01 (a later Easter shifts the
+	// whole window). If the cache ignored the year, this would wrongly
+	// return 2008's plan.
+	if got := compute("2035-04-01"); got == "joseph-spouse-of-the-bl-virgin-mary" {
+		t.Errorf("2035-04-01 = %q, want NOT joseph (that is 2008's landing day, not 2035's)", got)
+	}
+	if got := compute("2035-04-03"); got != "joseph-spouse-of-the-bl-virgin-mary" {
+		t.Errorf("2035-04-03 = %q, want joseph-spouse-of-the-bl-virgin-mary", got)
+	}
+}
+
+// TestEFTransferPlanCacheConcurrentUse exercises the memoised plan from many
+// goroutines at once -- gomobile may call Day/Days in from multiple threads,
+// and none of the tests above (all sequential) can catch a data race on the
+// shared cache map/list. Run with -race; it is the actual proof of the
+// "thread-safe" claim, not merely built with a mutex and assumed correct.
+func TestEFTransferPlanCacheConcurrentUse(t *testing.T) {
+	sel := calendar.DefaultSelection()
+	sel.Form = "old"
+	base := caldata.Tridentine()
+	overlay := calendar.Layer{ID: "user", Cels: map[string]calendar.RawCelebration{
+		"annunciation-of-the-blessed-virgin-mary": {
+			Fields:   map[string]string{"suppress": "true"},
+			Variants: map[string]map[string]string{},
+		},
+	}}
+	baseLayers := []calendar.Layer{base}
+	overlaidLayers := []calendar.Layer{base, overlay}
+
+	years := []int{2008, 2011, 2035, 2046}
+
+	var wg sync.WaitGroup
+	for g := 0; g < 12; g++ {
+		g := g
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			layers := baseLayers
+			if g%2 == 0 {
+				layers = overlaidLayers // different goroutines hammer different cache keys
+			}
+			for i := 0; i < 6; i++ {
+				y := years[(g+i)%len(years)]
+				for _, md := range []string{"03-19", "03-31", "04-01"} {
+					d, err := time.Parse("2006-01-02", time.Date(y, 1, 1, 0, 0, 0, 0, time.UTC).Format("2006")+"-"+md)
+					if err != nil {
+						t.Errorf("bad date: %v", err)
+						return
+					}
+					_ = calendar.Compute(d.UTC(), sel, layers).Observed.Slug
+				}
+			}
+		}()
+	}
+	wg.Wait()
+
+	// After the concurrent hammering, correctness must still hold for both
+	// keys -- the concurrency test is not a substitute for the correctness
+	// test above, so re-assert both outcomes here too.
+	d, _ := time.Parse("2006-01-02", "2008-04-01")
+	if got := calendar.Compute(d.UTC(), sel, baseLayers).Observed.Slug; got != "joseph-spouse-of-the-bl-virgin-mary" {
+		t.Errorf("after concurrent use, base 2008-04-01 = %q, want joseph-spouse-of-the-bl-virgin-mary", got)
+	}
+	if got := calendar.Compute(d.UTC(), sel, overlaidLayers).Observed.Slug; got == "joseph-spouse-of-the-bl-virgin-mary" {
+		t.Errorf("after concurrent use, overlaid 2008-04-01 = %q, want NOT joseph", got)
+	}
+}