feat(web): show ICS subscription events in detail view

2026-09-02 20:02:48 +02:00
parent e18c83b618
commit f34041d889
11 changed files with 908 additions and 80 deletions
@@ -0,0 +1,199 @@
+package icssub
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	ical "github.com/emersion/go-ical"
+)
+
+const sampleICS = "BEGIN:VCALENDAR\r\n" +
+	"VERSION:2.0\r\n" +
+	"PRODID:-//nidus//test//EN\r\n" +
+	"BEGIN:VEVENT\r\n" +
+	"UID:ev1@nidus.test\r\n" +
+	"DTSTAMP:20260101T000000Z\r\n" +
+	"DTSTART:20260805T090000Z\r\n" +
+	"DTEND:20260805T100000Z\r\n" +
+	"SUMMARY:Original title\r\n" +
+	"END:VEVENT\r\n" +
+	"END:VCALENDAR\r\n"
+
+func mustParseEvent(raw string) ical.Event {
+	cal, err := ical.NewDecoder(strings.NewReader(raw)).Decode()
+	if err != nil {
+		panic("mustParseEvent: " + err.Error())
+	}
+	evs := cal.Events()
+	if len(evs) == 0 {
+		panic("mustParseEvent: no events")
+	}
+	return evs[0]
+}
+
+// TestCacheFirstFetchPopulatesEntry verifies that the very first Get for a
+// URL does a foreground fetch and returns the parsed calendar.
+func TestCacheFirstFetchPopulatesEntry(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(sampleICS))
+	}))
+	defer srv.Close()
+
+	c := NewCache(time.Hour)
+	cal, err := c.Get(srv.URL)
+	if err != nil {
+		t.Fatalf("first Get: %v", err)
+	}
+	if len(cal.Events()) == 0 {
+		t.Fatalf("expected >=1 event, got 0")
+	}
+}
+
+// TestCacheStaleReturnsWithBackgroundRefresh verifies that once a cached
+// entry is stale, Get keeps returning the *stale* copy immediately while a
+// background refresh is spawned in a separate goroutine (rather than
+// blocking the caller on the network).
+func TestCacheStaleReturnsWithBackgroundRefresh(t *testing.T) {
+	var hits atomic.Int32
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		hits.Add(1)
+		time.Sleep(50 * time.Millisecond) // make the fetch slow enough to
+		w.WriteHeader(http.StatusOK)      // observe as background work
+		_, _ = w.Write([]byte(sampleICS))
+	}))
+	defer srv.Close()
+
+	c := NewCache(1 * time.Millisecond) // very short TTL
+	if _, err := c.Get(srv.URL); err != nil {
+		t.Fatalf("first Get: %v", err)
+	}
+	firstHits := hits.Load()
+
+	// Force staleness.
+	time.Sleep(3 * time.Millisecond)
+
+	// Subsequent Get must return the stale copy immediately without waiting
+	// for the slow server to respond — if it blocked, this call would take
+	// >= 50ms, which we bound with a deadline below via the hit counter.
+	st := time.Now()
+	cal, err := c.Get(srv.URL)
+	if err != nil {
+		t.Fatalf("second Get: %v", err)
+	}
+	if len(cal.Events()) == 0 {
+		t.Fatalf("expected event in stale response")
+	}
+	if time.Since(st) > 40*time.Millisecond {
+		t.Fatalf("second Get appears to have blocked on the network for %v", time.Since(st))
+	}
+
+	// Wait for the background refresh to complete.
+	deadline := time.Now().Add(2 * time.Second)
+	for hits.Load() == firstHits && time.Now().Before(deadline) {
+		time.Sleep(5 * time.Millisecond)
+	}
+	if hits.Load() == firstHits {
+		t.Fatalf("background refresh did not fire (hits stayed at %d)", firstHits)
+	}
+}
+
+// TestCacheConcurrentFirstFetchCoalesce ensures N concurrent first calls
+// for the same URL coalesce to a small number of actual origin fetches.
+func TestCacheConcurrentFirstFetchCoalesce(t *testing.T) {
+	var hits atomic.Int32
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		hits.Add(1)
+		time.Sleep(40 * time.Millisecond) // widen the coalescing window
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(sampleICS))
+	}))
+	defer srv.Close()
+
+	c := NewCache(time.Hour)
+
+	const n = 8
+	errs := make([]error, n)
+	var wg sync.WaitGroup
+	start := make(chan struct{})
+	for i := 0; i < n; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			<-start
+			_, err := c.Get(srv.URL)
+			errs[i] = err
+		}(i)
+	}
+	close(start)
+	wg.Wait()
+	for _, err := range errs {
+		if err != nil {
+			t.Fatalf("goroutine error: %v", err)
+		}
+	}
+	// Without coalescing we'd see n=8 hits; with it we expect a small
+	// constant (the first caller fetches; the rest either return the
+	// in-progress result or kick off a coalesced background refresh).
+	if hits.Load() > 3 {
+		t.Fatalf("expected coalescing to reduce fetches (got %d)", hits.Load())
+	}
+}
+
+// TestEventIDStable verifies that the same event hashes to the same ID
+// across calls, and is the right shape (32 hex chars + ".ics").
+func TestEventIDStable(t *testing.T) {
+	ev := mustParseEvent(sampleICS)
+	id1 := EventID(ev)
+	id2 := EventID(ev)
+	if id1 != id2 {
+		t.Fatalf("EventID not stable: %q vs %q", id1, id2)
+	}
+	if !strings.HasSuffix(id1, ".ics") {
+		t.Fatalf("EventID should end in .ics, got %q", id1)
+	}
+	if len(id1) != 32+4 {
+		t.Fatalf("expected 32 hex chars + .ics, got %q (len %d)", id1, len(id1))
+	}
+}
+
+// TestEventIDDiffersForDifferentEvents verifies that two events with
+// different titles or different start times hash to different IDs, while
+// two events with only a different UID hash to the same ID.
+func TestEventIDDiffersForDifferentEvents(t *testing.T) {
+	base := EventID(mustParseEvent(sampleICS))
+
+	// Different title.
+	rawA := strings.Replace(sampleICS, "SUMMARY:Original title", "SUMMARY:Other title", 1)
+	if EventID(mustParseEvent(rawA)) == base {
+		t.Fatal("same start, different title must hash differently")
+	}
+
+	// Different start time.
+	rawB := strings.Replace(sampleICS, "DTSTART:20260805T090000Z", "DTSTART:20260806T090000Z", 1)
+	if EventID(mustParseEvent(rawB)) == base {
+		t.Fatal("different start times must hash differently")
+	}
+
+	// Same start, same title, different UID → same hash.
+	rawC := strings.Replace(sampleICS, "UID:ev1@nidus.test", "UID:ev2@nidus.test", 1)
+	if EventID(mustParseEvent(rawC)) != base {
+		t.Fatal("UID should not affect the hash — same start/dur/title must be equal")
+	}
+}
+
+// TestEventIDWorksWithoutUID verifies EventID still produces a value (from
+// DTSTART+DTEND+SUMMARY) when the event has no UID property.
+func TestEventIDWorksWithoutUID(t *testing.T) {
+	raw := strings.Replace(sampleICS, "UID:ev1@nidus.test\r\n", "", 1)
+	ev := mustParseEvent(raw)
+	id := EventID(ev)
+	if id == "" {
+		t.Fatal("EventID should be non-empty even without UID")
+	}
+}