Push the week's plan to Google Calendar (Feature 16)

POST /api/v1/plans/{weekStart}/push-calendar writes one event per plan
day to the chosen calendar: "Dinner: {name}" from the household dinner
time for 60 minutes in the household zone, with the dinner name,
"Start by {time}" for crock-pot dinners and the
{MEALQUEST_PUBLIC_URL}/dinner/{id} link. Event ids are the lowercase
base32hex SHA-256 of "mealquest|{weekStart}|{date}"; each event is
inserted, and a 409 updates it instead.

gcal.Service.PushEvents does the Calendar writes under the account lock,
with the same redaction as listing. plan.Service.Push records a push only
when every event was written: the plan becomes synced with
calendar_synced_at and each day stores its event id. A partial failure
records nothing; a plan edited mid-push is 409 plan_changed.

A swap, or a redraft to another dinner, clears the day's
calendar_event_id, so the next push writes just those days; a push with
none pending writes every day again.

No calendar chosen is 409 no_calendar; a deleted or read-only chosen
calendar is 409 calendar_unavailable; a refused grant is 502
reconnect_required, leaving the connection as it is.

Maestro task 5885d2b1-cf06-44ff-abf3-242d7763c3c9.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/gcal/events_test.go

@@ -0,0 +1,156 @@
+package gcal_test
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/gcal"
+)
+
+// chosen is a harness connected with dinners chosen as the calendar to
+// push to.
+func chosen(t *testing.T) *harness {
+	t.Helper()
+	h := connected(t)
+	if _, err := h.svc.SelectCalendar(context.Background(), dinners.ID); err != nil {
+		t.Fatal(err)
+	}
+	return h
+}
+
+// event is a valid event with id.
+func event(id string) gcal.Event {
+	start := time.Date(2026, 10, 12, 21, 30, 0, 0, time.UTC)
+	return gcal.Event{ID: id, Summary: "Dinner: Beef Chili", Description: "Beef Chili",
+		Start: start, End: start.Add(time.Hour), TimeZone: "America/New_York"}
+}
+
+func TestPushEventsInsertsThenUpdates(t *testing.T) {
+	t.Parallel()
+	h := chosen(t)
+	if err := h.svc.PushEvents(context.Background(), []gcal.Event{event("abcde0"), event("abcde1")}); err != nil {
+		t.Fatalf("PushEvents: %v", err)
+	}
+	renamed := event("abcde0")
+	renamed.Summary = "Dinner: Pot Roast"
+	if err := h.svc.PushEvents(context.Background(), []gcal.Event{renamed}); err != nil {
+		t.Fatalf("PushEvents again: %v", err)
+	}
+	if inserts, updates := h.google.EventWrites(); inserts != 2 || updates != 1 {
+		t.Errorf("%d inserts and %d updates, want 2 and 1", inserts, updates)
+	}
+	events := h.google.Events(dinners.ID)
+	if len(events) != 2 || events["abcde0"].Summary != "Dinner: Pot Roast" {
+		t.Errorf("events = %+v", events)
+	}
+	if got := events["abcde1"].Start.DateTime; got != "2026-10-12T21:30:00Z" {
+		t.Errorf("start = %s, want the instant as given", got)
+	}
+}
+
+func TestPushEventsRefusesInvalidEvents(t *testing.T) {
+	t.Parallel()
+	h := chosen(t)
+	before := h.google.TokenCalls()
+	for name, edit := range map[string]func(*gcal.Event){
+		"uppercase id":      func(e *gcal.Event) { e.ID = "ABCDE" },
+		"id outside a-v":    func(e *gcal.Event) { e.ID = "abcdw" },
+		"id too short":      func(e *gcal.Event) { e.ID = "abcd" },
+		"id too long":       func(e *gcal.Event) { e.ID = strings.Repeat("a", 1025) },
+		"no summary":        func(e *gcal.Event) { e.Summary = "" },
+		"ends as it starts": func(e *gcal.Event) { e.End = e.Start },
+		"no time zone":      func(e *gcal.Event) { e.TimeZone = "" },
+	} {
+		ev := event("abcde")
+		edit(&ev)
+		if err := h.svc.PushEvents(context.Background(), []gcal.Event{event("abcde0"), ev}); err == nil {
+			t.Errorf("%s: PushEvents succeeded", name)
+		}
+	}
+	if err := h.svc.PushEvents(context.Background(), nil); err == nil {
+		t.Error("PushEvents of no events succeeded")
+	}
+	if err := h.svc.PushEvents(context.Background(), []gcal.Event{event(strings.Repeat("v", 1024))}); err != nil {
+		t.Errorf("PushEvents of a 1024-character id: %v", err)
+	}
+	if inserts, _ := h.google.EventWrites(); inserts != 1 {
+		t.Errorf("%d events inserted, want only the valid one", inserts)
+	}
+	if n := h.google.TokenCalls() - before; n != 1 {
+		t.Errorf("token endpoint called %d times, want once, for the valid push", n)
+	}
+}
+
+func TestPushEventsGrantNoLongerAccepted(t *testing.T) {
+	t.Parallel()
+	h := chosen(t)
+	h.google.FailEventWrite(1, http.StatusUnauthorized)
+	err := h.svc.PushEvents(context.Background(), []gcal.Event{event("abcde")})
+	if !errors.Is(err, gcal.ErrReconnect) {
+		t.Fatalf("PushEvents = %v, want ErrReconnect", err)
+	}
+	assertNoSecret(t, "error", err.Error())
+	if _, ok := h.row(t); !ok {
+		t.Error("a refused grant forgot the connection")
+	}
+}
+
+func TestPushEventsGoogleFailureIsRedacted(t *testing.T) {
+	t.Parallel()
+	for name, n := range map[string]int{"insert": 1, "update": 2} {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			h := chosen(t)
+			if name == "update" {
+				if err := h.svc.PushEvents(context.Background(), []gcal.Event{event("abcde")}); err != nil {
+					t.Fatal(err)
+				}
+			}
+			// The fake's failure body quotes the access token.
+			h.google.FailEventWrite(n, http.StatusInternalServerError)
+			err := h.svc.PushEvents(context.Background(), []gcal.Event{event("abcde")})
+			var calendar *gcal.CalendarError
+			if !errors.As(err, &calendar) {
+				t.Fatalf("PushEvents = %v, want *CalendarError", err)
+			}
+			if !strings.Contains(err.Error(), "event "+name) || !strings.Contains(err.Error(), "HTTP 500") {
+				t.Errorf("error = %q, want the failed %s and its status", err, name)
+			}
+			assertNoSecret(t, "error", err.Error())
+		})
+	}
+}
+
+// TestPushEventsHoldsTheAccount holds an event write at Google while a
+// disconnect starts: the disconnect waits for the push, so it never
+// revokes the token the push is using.
+func TestPushEventsHoldsTheAccount(t *testing.T) {
+	t.Parallel()
+	h := chosen(t)
+	arrived, release := h.google.HoldEvents()
+	defer release()
+	pushed := make(chan error, 1)
+	go func() { pushed <- h.svc.PushEvents(context.Background(), []gcal.Event{event("abcde")}) }()
+	<-arrived
+	disconnected := make(chan error, 1)
+	go func() { disconnected <- h.svc.Disconnect(context.Background()) }()
+	select {
+	case err := <-disconnected:
+		t.Fatalf("Disconnect finished (%v) while a push was at Google", err)
+	case <-time.After(200 * time.Millisecond):
+	}
+	if n := len(h.google.Revoked()); n != 0 {
+		t.Fatalf("revoked %d tokens while a push was at Google", n)
+	}
+	release()
+	if err := <-pushed; err != nil {
+		t.Errorf("PushEvents: %v", err)
+	}
+	if err := <-disconnected; err != nil {
+		t.Errorf("Disconnect: %v", err)
+	}
+}