Implement Knowledge City platform, organizer and DAV integration

Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
This commit is contained in:
Anya Tokugawa committed 2026-09-27 14:44:43 +09:00
1 parent 288e6e94ac
commit c1175d389f
699 files changed
+110197 -4117

No files matched your search

+163
View File
@@ -0,0 +1,163 @@
package server
import (
"context"
"encoding/json"
"strings"
"testing"
"pageswiki/internal/store"
)
func TestTaskActivityDoesNotScheduleCityOrLeakContent(t *testing.T) {
s, _, domain, actor := taskFixture(t)
ctx := context.Background()
if err := s.reconcileCityActivity(domain); err != nil {
t.Fatal(err)
}
cp, err := s.store.ActivityOutboxCheckpoint("city", domain)
if err != nil {
t.Fatal(err)
}
item := newTaskRecord("task", "SECRET TASK TITLE")
item.Notes = "SECRET NOTES"
item, err = s.store.SaveTask(ctx, domain, actor, item, 0)
if err != nil {
t.Fatal(err)
}
s.enqueueCityActivityEvents()
var jobs int
if err = s.store.DB.QueryRow(`SELECT count(*) FROM event_jobs WHERE event_type=?`, cityReconcileEventType).Scan(&jobs); err != nil || jobs != 0 {
t.Fatal("task triggered City job", jobs, err)
}
if err = s.reconcileCityActivity(domain); err != nil {
t.Fatal(err)
}
after, err := s.store.ActivityOutboxCheckpoint("city", domain)
if err != nil || after.LastSequence != cp.LastSequence {
t.Fatal("unrelated cursor advance", after, err)
}
sub := store.ActivitySubscription{ConsumerID: "task-fixture", EventTypes: []string{"organizer.task.changed"}}
events, err := s.store.ActivityOutboxForConsumer(ctx, sub, domain, 10)
if err != nil || len(events) != 1 {
t.Fatal(events, err)
}
b, _ := json.Marshal(events)
if strings.Contains(string(b), "SECRET") {
t.Fatal("task content copied to common outbox")
}
if events[0].TargetUUID != item.UUID || events[0].ActorUUID != actor {
t.Fatal(events[0])
}
// Same-domain page changes must still schedule/reconcile City normally.
if _, err = s.store.CreatePageAtPathInDomain(domain, "/activity/fixture/page"); err != nil {
t.Fatal(err)
}
s.enqueueCityActivityEvents()
if err = s.store.DB.QueryRow(`SELECT count(*) FROM event_jobs WHERE event_type=?`, cityReconcileEventType).Scan(&jobs); err != nil || jobs != 1 {
t.Fatal(jobs, err)
}
if err = s.reconcileCityActivity(domain); err != nil {
t.Fatal(err)
}
events, err = s.store.ActivityOutboxForConsumer(ctx, sub, domain, 10)
if err != nil || len(events) != 1 {
t.Fatal("City acknowledged task consumer", events, err)
}
}
func TestTaskOutboxFailureRollsBackEntireMutation(t *testing.T) {
s, _, domain, actor := taskFixture(t)
if _, err := s.store.DB.Exec(`CREATE TRIGGER reject_task_outbox BEFORE INSERT ON activity_outbox WHEN NEW.event_type='organizer.task.changed' BEGIN SELECT RAISE(ABORT,'test outbox failure'); END`); err != nil {
t.Fatal(err)
}
item := newTaskRecord("task", "atomic")
if _, err := s.store.SaveTask(context.Background(), domain, actor, item, 0); err == nil {
t.Fatal("outbox failure ignored")
}
for _, table := range []string{"organizer_items", "organizer_revisions", "organizer_changes", "activity_outbox_heads"} {
var count int
if err := s.store.DB.QueryRow(`SELECT count(*) FROM ` + table).Scan(&count); err != nil || count != 0 {
t.Fatal(table, count, err)
}
}
if _, err := s.store.DB.Exec(`DROP TRIGGER reject_task_outbox`); err != nil {
t.Fatal(err)
}
if _, err := s.store.SaveTask(context.Background(), domain, actor, item, 0); err != nil {
t.Fatal(err)
}
if _, err := s.store.SaveTask(context.Background(), domain, actor, item, 0); err != nil {
t.Fatal("create retry", err)
}
var count int
if err := s.store.DB.QueryRow(`SELECT count(*) FROM activity_outbox WHERE event_type='organizer.task.changed'`).Scan(&count); err != nil || count != 1 {
t.Fatal("duplicate create event", count, err)
}
}
func TestTaskActivityBridgeResumesAndPreservesSchedule(t *testing.T) {
s, _, domain, actor := taskFixture(t)
ctx := context.Background()
item, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("task", "old task"), 0)
if err != nil {
t.Fatal(err)
}
item.Status = "done"
item, err = s.store.SaveTask(ctx, domain, actor, item, 1)
if err != nil {
t.Fatal(err)
}
if _, err = s.store.DB.Exec(`DELETE FROM activity_outbox WHERE event_type='organizer.task.changed'`); err != nil {
t.Fatal(err)
}
if _, err = s.store.DB.Exec(`CREATE TRIGGER fail_bridge BEFORE INSERT ON activity_outbox BEGIN SELECT RAISE(ABORT,'test migration failure'); END`); err != nil {
t.Fatal(err)
}
if _, _, err = s.store.PublishTaskActivity(ctx, 1); err == nil {
t.Fatal("bridge failure ignored")
}
var seq int64
if err = s.store.DB.QueryRow(`SELECT last_sequence FROM organizer_activity_bridge WHERE id=1`).Scan(&seq); err != nil || seq != 0 {
t.Fatal("cursor advanced on failure", seq, err)
}
if _, err = s.store.DB.Exec(`DROP TRIGGER fail_bridge`); err != nil {
t.Fatal(err)
}
for i := 0; i < 2; i++ {
n, p, e := s.store.PublishTaskActivity(ctx, 1)
if e != nil || n != 1 || p != 1 {
t.Fatal(n, p, e)
}
}
if n, p, e := s.store.PublishTaskActivity(ctx, 1); e != nil || n != 0 || p != 0 {
t.Fatal(n, p, e)
}
item.Status = "todo"
if _, err = s.store.SaveTask(ctx, domain, actor, item, 2); err != nil {
t.Fatal(err)
}
if n, p, e := s.store.PublishTaskActivity(ctx, 100); e != nil || n != 1 || p != 0 {
t.Fatal("direct commit duplicated", n, p, e)
}
var count int
if err = s.store.DB.QueryRow(`SELECT count(*) FROM activity_outbox WHERE event_type='organizer.task.changed'`).Scan(&count); err != nil || count != 3 {
t.Fatal(count, err)
}
if err = s.store.EnsureTaskActivityBridgeEvent(); err != nil {
t.Fatal(err)
}
if _, err = s.store.DB.Exec(`UPDATE event_definitions SET enabled=0,interval_seconds=600 WHERE uuid='builtin.task.activity.publish'`); err != nil {
t.Fatal(err)
}
if err = s.store.EnsureTaskActivityBridgeEvent(); err != nil {
t.Fatal(err)
}
var enabled, interval int
if err = s.store.DB.QueryRow(`SELECT enabled,interval_seconds FROM event_definitions WHERE uuid='builtin.task.activity.publish'`).Scan(&enabled, &interval); err != nil || enabled != 0 || interval != 600 {
t.Fatal(enabled, interval, err)
}
if err = s.runEvent(&store.EventJob{Type: store.TaskActivityBridgeEventType}); err != nil {
t.Fatal("queue handler", err)
}
}