Files
pages/internal/store/calendar_backend_test.go
2026-11-15 05:47:14 +09:00

317 lines
11 KiB
Go

package store
import (
"context"
"encoding/json"
"errors"
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/google/uuid"
"pageswiki/internal/calendar"
)
func calendarEvent(t *testing.T, uid string, start time.Time) calendar.Event {
t.Helper()
e, err := calendar.Build("", calendar.Event{UID: uid, Summary: "日本語の予定", Start: start, End: start.Add(time.Hour)})
if err != nil {
t.Fatal(err)
}
return e
}
func TestCalendarBackendContract(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d, a := productivityBackendFixture(t, b)
ctx := context.Background()
r, err := s.NewCalendarRepository(ctx)
if err != nil {
t.Fatal(err)
}
peer, err := s.NewCalendarRepository(ctx)
if err != nil {
t.Fatal("schema replay", err)
}
c, err := r.Create(ctx, d, a, "予定", "予定表")
if err != nil {
t.Fatal(err)
}
if _, err = r.Create(ctx, d, a, "duplicate", "予定表"); !errors.Is(err, calendar.ErrNameTaken) {
t.Fatal(err)
}
if err = r.SaveDefaults(ctx, d, a, []string{c.ID}); err != nil {
t.Fatal(err)
}
if ids, err := peer.Defaults(d, a); err != nil || len(ids) != 1 || ids[0] != c.ID {
t.Fatal(ids, err)
}
start := time.Date(2026, 11, 30, 12, 0, 0, 0, time.UTC)
e := calendarEvent(t, "test@example.invalid", start)
saved, created, err := r.ChangeDAV(ctx, d, c.ID, a, "client.ics", "*", &e, nil)
if err != nil || !created {
t.Fatal(saved, created, err)
}
if _, _, err = r.ChangeDAV(ctx, d, c.ID, a, "alias.ics", "*", &e, nil); !errors.Is(err, calendar.ErrConflict) {
t.Fatal(err)
}
meta, items, err := peer.DAVSnapshot(ctx, d, c.ID, a, false)
if err != nil || len(items) != 1 || items[0].Data != "" || calendar.DAVFilename(meta, e.UID) != "client.ics" {
t.Fatal(meta, items, err)
}
if tags, err := r.QueryETags(ctx, d, c.ID, a, start.Add(-time.Hour), start.Add(2*time.Hour)); err != nil || len(tags) != 1 || tags[0].ETag != saved.ETag {
t.Fatal(tags, err)
}
if upcoming, err := r.Upcoming(ctx, d, c.ID, a, start, start.Add(2*time.Hour)); err != nil || len(upcoming) != 1 || upcoming[0].Summary != e.Summary {
t.Fatal(upcoming, err)
}
if _, err = r.Event(ctx, d, c.ID, uuid.NewString(), e.UID); !errors.Is(err, calendar.ErrMissing) {
t.Fatal("private read", err)
}
if _, err = r.Event(ctx, uuid.NewString(), c.ID, a, e.UID); !errors.Is(err, calendar.ErrMissing) {
t.Fatal("domain isolation", err)
}
moved := calendarEvent(t, e.UID, start.Add(48*time.Hour))
if _, _, err = peer.ChangeDAV(ctx, d, c.ID, a, "client.ics", saved.ETag, &moved, nil); err != nil {
t.Fatal(err)
}
if _, _, err = r.ChangeDAV(ctx, d, c.ID, a, "client.ics", saved.ETag, &e, nil); !errors.Is(err, calendar.ErrConflict) {
t.Fatal("stale ETag", err)
}
for _, table := range []string{"calendar_event_cache", "calendar_month_cache", "calendar_index_state"} {
if _, err = s.DB.Exec(`DELETE FROM ` + table); err != nil {
t.Fatal(err)
}
}
got, err := r.Event(ctx, d, c.ID, a, e.UID)
if err != nil || !got.Start.Equal(moved.Start) {
t.Fatal("rebuild", got, err)
}
meta, err = r.Get(d, c.ID, a)
if err != nil || len(meta.Months) != 1 || meta.Months["2026-12"] == "" {
t.Fatal(meta, err)
}
meta, err = r.Settings(ctx, d, c.ID, a, meta.Version, "renamed", false, nil, "new-name")
if err != nil {
t.Fatal(err)
}
if _, items, err = peer.DAVSnapshot(ctx, d, c.ID, a, true); err != nil || len(items) != 1 || items[0].Data == "" {
t.Fatal(items, err)
}
reader := uuid.NewString()
meta, err = r.Settings(ctx, d, c.ID, a, meta.Version, meta.Name, false, map[string]string{reader: "read"})
if err != nil {
t.Fatal(err)
}
if _, err = r.Event(ctx, d, c.ID, reader, e.UID); err != nil {
t.Fatal(err)
}
if _, err = r.Change(ctx, d, c.ID, reader, e.UID, moved.ETag, nil); !errors.Is(err, calendar.ErrForbidden) {
t.Fatal("read collaborator wrote", err)
}
if _, err = r.Settings(ctx, d, c.ID, reader, meta.Version, "hijack", false, nil); !errors.Is(err, calendar.ErrForbidden) {
t.Fatal(err)
}
meta, err = r.Settings(ctx, d, c.ID, a, meta.Version, meta.Name, false, nil)
if err != nil {
t.Fatal(err)
}
if _, err = peer.Event(ctx, d, c.ID, reader, e.UID); !errors.Is(err, calendar.ErrMissing) {
t.Fatal("revoked member", err)
}
if err = r.Delete(ctx, d, c.ID, a, "stale"); !errors.Is(err, calendar.ErrConflict) {
t.Fatal(err)
}
if err = r.Delete(ctx, d, c.ID, a, meta.Version); err != nil {
t.Fatal(err)
}
if _, err = peer.Get(d, c.ID, a); !errors.Is(err, calendar.ErrMissing) {
t.Fatal(err)
}
if ids, err := r.Defaults(d, a); err != nil || len(ids) != 0 {
t.Fatal(ids, err)
}
var n int
if err = s.DB.QueryRow(`SELECT count(*) FROM calendar_event_cache`).Scan(&n); err != nil || n != 0 {
t.Fatal(n, err)
}
})
}
}
func TestCalendarTaskBlockBackend(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d, a := productivityBackendFixture(t, b)
ctx := context.Background()
r, err := s.NewCalendarRepository(ctx)
if err != nil {
t.Fatal(err)
}
c, err := r.Create(ctx, d, a, "Personal")
if err != nil {
t.Fatal(err)
}
task, err := s.SaveTask(ctx, d, a, TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "作業", Status: "todo", Bucket: "inbox"}, 0)
if err != nil {
t.Fatal(err)
}
start := time.Date(2026, 11, 15, 9, 0, 0, 0, time.UTC)
block, err := s.ReserveTaskBlock(ctx, d, a, TaskBlock{UUID: uuid.NewString(), TaskUUID: task.UUID, CalendarUUID: c.ID, Start: start, End: start.Add(time.Hour)}, task.Version)
if err != nil {
t.Fatal(err)
}
e := calendarEvent(t, block.EventUID, start)
_, event, err := r.TaskBlock(ctx, d, c.ID, a, block.EventUID, &e)
if err != nil {
t.Fatal(err)
}
if err = s.SetTaskBlockState(ctx, d, a, block.UUID, "active"); err != nil {
t.Fatal(err)
}
moved := calendarEvent(t, block.EventUID, start.Add(2*time.Hour))
if _, err = r.Change(ctx, d, c.ID, a, block.EventUID, event.ETag, &moved); err != nil {
t.Fatal(err)
}
_, retried, err := r.TaskBlock(ctx, d, c.ID, a, block.EventUID, &e)
if err != nil || !retried.Start.Equal(moved.Start) {
t.Fatal("retry overwrote changed schedule", retried, err)
}
err = r.ReadPersonalLocalIndex(ctx, d, c.ID, a, func(calendar.Calendar) error {
blocks, more, e := s.TaskDayBlocks(ctx, d, a, c.ID, start.Add(-time.Hour), start.Add(24*time.Hour))
if e != nil || more || len(blocks) != 1 || blocks[0].Start != moved.Start.UnixMilli() || blocks[0].Title != task.Title {
t.Fatalf("blocks=%v more=%v error=%v", blocks, more, e)
}
return nil
})
if err != nil {
t.Fatal(err)
}
// Synthetic metadata only; a deliberately missing file proves that
// external-source contents are rejected BEFORE refresh/read occurs.
guard, err := r.Create(ctx, d, a, "External guard")
if err != nil {
t.Fatal(err)
}
guard.Source = &calendar.Source{Kind: "ics", URL: "https://example.invalid/never-fetch"}
guard.Months = map[string]string{"2026-11": strings.Repeat("a", 64)}
data, _ := json.Marshal(guard)
if err = os.WriteFile(filepath.Join(r.Root, d, guard.ID, "calendar.json"), data, 0600); err != nil {
t.Fatal(err)
}
if _, _, err = r.TaskBlock(ctx, d, guard.ID, a, "blocked", nil); !errors.Is(err, calendar.ErrForbidden) {
t.Fatal("external snapshot touched", err)
}
called := false
err = r.ReadPersonalLocalIndex(ctx, d, guard.ID, a, func(calendar.Calendar) error { called = true; return nil })
if called || !errors.Is(err, calendar.ErrForbidden) {
t.Fatal(called, err)
}
})
}
}
func TestPostgreSQLCalendarRecoveryAndConcurrency(t *testing.T) {
s, d, a := productivityBackendFixture(t, storePostgreSQL)
ctx := context.Background()
r, err := s.NewCalendarRepository(ctx)
if err != nil {
t.Fatal(err)
}
peer, err := s.NewCalendarRepository(ctx)
if err != nil {
t.Fatal(err)
}
c, err := r.Create(ctx, d, a, "recovery")
if err != nil {
t.Fatal(err)
}
start := time.Date(2026, 11, 15, 9, 0, 0, 0, time.UTC)
e := calendarEvent(t, "concurrent", start)
if _, err = r.Change(ctx, d, c.ID, a, e.UID, "*", &e); err != nil {
t.Fatal(err)
}
if _, err = r.Event(ctx, d, c.ID, a, e.UID); err != nil {
t.Fatal(err)
}
ch := make(chan error, 2)
for i, w := range []*calendar.Repository{r, peer} {
go func(i int, w *calendar.Repository) {
v, err := calendar.Build(e.Data, calendar.Event{UID: e.UID, Summary: fmt.Sprint(i), Start: start.Add(time.Duration(i+1) * time.Hour), End: start.Add(time.Duration(i+2) * time.Hour)})
if err == nil {
_, err = w.Change(ctx, d, c.ID, a, e.UID, e.ETag, &v)
}
ch <- err
}(i, w)
}
wins := 0
for i := 0; i < 2; i++ {
err := <-ch
if err == nil {
wins++
} else if !errors.Is(err, calendar.ErrConflict) {
t.Fatal(err)
}
}
if wins != 1 {
t.Fatal(wins)
}
current, err := r.Event(ctx, d, c.ID, a, e.UID)
if err != nil {
t.Fatal(err)
}
var version string
if err = s.DB.QueryRow(`SELECT version FROM calendar_index_state WHERE domain=$1 AND calendar=$2`, d, c.ID).Scan(&version); err != nil {
t.Fatal(err)
}
moved := calendarEvent(t, e.UID, start.AddDate(0, 1, 0))
if _, err = r.Change(ctx, d, c.ID, a, e.UID, current.ETag, &moved); err != nil {
t.Fatal(err)
}
// Canonical manifest is committed; fail rebuilding its new generation.
if _, err = s.DB.Exec(`ALTER TABLE calendar_event_cache ADD CONSTRAINT synthetic_calendar_failure CHECK(month <> '2026-12')`); err != nil {
t.Fatal(err)
}
if _, err = r.Event(ctx, d, c.ID, a, e.UID); err == nil || strings.Contains(err.Error(), "concurrent") {
t.Fatal("cache failure not sanitized", err)
}
var after string
if err = s.DB.QueryRow(`SELECT version FROM calendar_index_state WHERE domain=$1 AND calendar=$2`, d, c.ID).Scan(&after); err != nil || after != version {
t.Fatal("partial cache commit", after, err)
}
if _, err = s.DB.Exec(`ALTER TABLE calendar_event_cache DROP CONSTRAINT synthetic_calendar_failure`); err != nil {
t.Fatal(err)
}
got, err := peer.Event(ctx, d, c.ID, a, e.UID)
if err != nil || !got.Start.Equal(moved.Start) {
t.Fatal("recovery", got, err)
}
if _, err = r.Change(ctx, d, c.ID, a, e.UID, current.ETag, &e); !errors.Is(err, calendar.ErrConflict) {
t.Fatal("lost response retry", err)
}
meta, err := r.Get(d, c.ID, a)
if err != nil {
t.Fatal(err)
}
// Cache deletion failure must leave the canonical calendar visible.
if _, err = s.DB.Exec(`ALTER TABLE calendar_month_cache RENAME COLUMN calendar TO unavailable_calendar`); err != nil {
t.Fatal(err)
}
if err = r.Delete(ctx, d, c.ID, a, meta.Version); err == nil {
t.Fatal("delete fault ignored")
}
if _, err = peer.Get(d, c.ID, a); err != nil {
t.Fatal("canonical lost on failed delete", err)
}
if _, err = s.DB.Exec(`ALTER TABLE calendar_month_cache RENAME COLUMN unavailable_calendar TO calendar`); err != nil {
t.Fatal(err)
}
if err = r.Delete(ctx, d, c.ID, a, meta.Version); err != nil {
t.Fatal(err)
}
}