package server
import (
"context"
"encoding/base64"
"encoding/json"
"encoding/xml"
"errors"
"net/http/httptest"
"strings"
"sync"
"testing"
"time"
"pageswiki/internal/store"
)
func davTaskRequest(s *Server, auth, method, path, body string, headers map[string]string) *httptest.ResponseRecorder {
r := httptest.NewRequest(method, "http://localhost"+path, strings.NewReader(body))
r.Header.Set("Authorization", auth)
r.Header.Set("Depth", "1")
r.Header.Set("Content-Type", "text/calendar")
for k, v := range headers {
r.Header.Set(k, v)
}
w := httptest.NewRecorder()
s.withAuthorization(s.mux).ServeHTTP(w, r)
return w
}
const taskICALFixture = "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//CLI test//EN\r\nBEGIN:VTODO\r\nUID:cli-task@example.test\r\nDTSTAMP:20260925T000000Z\r\nSUMMARY:CLI task\r\nDESCRIPTION:Private note\\nSecond line\r\nSTATUS:NEEDS-ACTION\r\nPRIORITY:3\r\nDUE;VALUE=DATE:20261001\r\nCATEGORIES:Test,CLI\r\nX-CLIENT-TEST:retained\r\nEND:VTODO\r\nEND:VCALENDAR\r\n"
func TestTaskDAVRoundTrip(t *testing.T) {
s, token, domain, actor := taskFixture(t)
auth := "Bearer " + token
ctx := context.Background()
request := func(method, path, body string, h map[string]string, want int) *httptest.ResponseRecorder {
t.Helper()
w := davTaskRequest(s, auth, method, path, body, h)
if w.Code != want {
t.Fatalf("%s %s: %d want %d %s", method, path, w.Code, want, w.Body)
}
return w
}
home := request("PROPFIND", taskDAVRoot, ``, nil, 207)
if !strings.Contains(home.Body.String(), taskDAVCollection) {
t.Fatal(home.Body)
}
p := taskDAVCollection + "client-name.ics"
request("PUT", p, taskICALFixture, map[string]string{"If-None-Match": "*"}, 201)
item, err := s.store.TaskDAVByName(ctx, domain, actor, "client-name.ics")
if err != nil || item.DueOn != "2026-10-01" || item.Notes != "Private note\nSecond line" || item.Priority != 2 {
t.Fatal(item, err)
}
get := request("GET", p, "", nil, 200)
tag := get.Header().Get("ETag")
if tag == "" || !strings.Contains(get.Body.String(), "X-CLIENT-TEST:retained") {
t.Fatal(get.Body)
}
if _, err = parseTaskICAL(get.Body.String()); err != nil {
t.Fatal(err, get.Body)
}
request("GET", p, "", map[string]string{"If-None-Match": tag}, 304)
request("PUT", p, taskICALFixture, nil, 204)
get = request("GET", p, "", nil, 200)
tag = get.Header().Get("ETag")
request("PUT", p, taskICALFixture, map[string]string{"If-Match": `"stale"`}, 412)
request("PUT", p, taskICALFixture, map[string]string{"If-None-Match": "*"}, 412)
request("PUT", taskDAVCollection+"other.ics", taskICALFixture, map[string]string{"If-None-Match": "*"}, 403)
completed := strings.Replace(get.Body.String(), "STATUS:NEEDS-ACTION", "STATUS:COMPLETED", 1)
request("PUT", p, completed, map[string]string{"If-Match": tag}, 204)
item, err = s.store.GetTask(ctx, domain, actor, item.UUID)
if err != nil || item.Status != "done" || item.CompletedMS == 0 {
t.Fatal(item, err)
}
get = request("GET", p, "", nil, 200)
if get.Header().Get("ETag") == tag {
t.Fatal("unchanged etag")
}
tag = get.Header().Get("ETag")
// Web edits preserve UID/name and metadata even if not sent by the UI.
item.Title = "Web title 日本語"
item.CalDAV = nil
if _, err = s.store.SaveTask(ctx, domain, actor, item, item.Version); err != nil {
t.Fatal(err)
}
get = request("GET", p, "", nil, 200)
if !strings.Contains(get.Body.String(), "SUMMARY:Web title 日本語") || !strings.Contains(get.Body.String(), "CATEGORIES:Test,CLI") || get.Header().Get("ETag") == tag {
t.Fatal(get.Body)
}
query := ``
report := request("REPORT", taskDAVCollection, query, nil, 207)
if !strings.Contains(report.Body.String(), "STATUS:COMPLETED") {
t.Fatal("completed tasks missing", report.Body)
}
var n davNode
if err = xml.Unmarshal(report.Body.Bytes(), &n); err != nil {
t.Fatal(err)
}
badFilter := strings.Replace(query, ``, ``, 1)
request("REPORT", taskDAVCollection, badFilter, nil, 403)
multi := `` + p + `` + taskDAVCollection + `missing.icshttps://evil.test` + p + ``
report = request("REPORT", taskDAVCollection, multi, nil, 207)
if strings.Count(report.Body.String(), "404 Not Found") != 2 {
t.Fatal(report.Body)
}
request("DELETE", p, "", map[string]string{"If-Match": get.Header().Get("ETag")}, 204)
request("GET", p, "", nil, 404)
report = request("REPORT", taskDAVCollection, query, nil, 207)
if strings.Contains(report.Body.String(), p) {
t.Fatal("archived task in collection")
}
item, err = s.store.GetTask(ctx, domain, actor, item.UUID)
if err != nil || !item.Archived {
t.Fatal("delete must archive", err)
}
item.Archived = false
if _, err = s.store.SaveTask(ctx, domain, actor, item, item.Version); err != nil {
t.Fatal(err)
}
request("GET", p, "", nil, 200)
}
func TestTaskDAVCredentialsIsolation(t *testing.T) {
s, token, domain, actor := taskFixture(t)
ctx := context.Background()
w := taskRequest(s, token, "POST", "dav-credentials", map[string]any{"label": "CLI", "write": true, "days": 30}, "")
if w.Code != 201 {
t.Fatal(w.Code, w.Body)
}
var c struct {
Username, Password string
Credential store.TaskDAVCredential
}
if err := json.Unmarshal(w.Body.Bytes(), &c); err != nil {
t.Fatal(err)
}
auth := "Basic " + base64.StdEncoding.EncodeToString([]byte(c.Username+":"+c.Password))
req := func(method, path, body string, headers map[string]string, want int) {
t.Helper()
w := davTaskRequest(s, auth, method, path, body, headers)
if w.Code != want {
t.Fatal(method, path, w.Code, w.Body)
}
}
req("PROPFIND", taskDAVRoot, "", nil, 207)
req("PUT", taskDAVCollection+"one.ics", taskICALFixture, map[string]string{"If-None-Match": "*"}, 201)
req("GET", tasksAPI+"items", "", nil, 401)
req("POST", tasksAPI+"dav-credentials", `{"label":"escalation","write":true}`, nil, 401)
list := taskRequest(s, token, "GET", "dav-credentials", nil, "")
if list.Code != 200 || strings.Contains(list.Body.String(), c.Password) || strings.Contains(list.Body.String(), "secret_hash") {
t.Fatal(list.Body)
}
var hash string
s.store.DB.QueryRow(`SELECT secret_hash FROM organizer_dav_credentials WHERE id=?`, c.Username).Scan(&hash)
if hash == "" || hash == c.Password {
t.Fatal("credential not hashed")
}
credential, pass, err := s.store.CreateTaskDAVCredential(ctx, domain, actor, "Reader", false, 1)
if err != nil {
t.Fatal(err)
}
auth = "Basic " + base64.StdEncoding.EncodeToString([]byte(credential.ID+":"+pass))
req("GET", taskDAVCollection+"one.ics", "", nil, 200)
req("PUT", taskDAVCollection+"two.ics", taskICALFixture, map[string]string{"If-None-Match": "*"}, 403)
if err = s.store.RevokeTaskDAVCredential(ctx, domain, actor, credential.ID); err != nil {
t.Fatal(err)
}
req("GET", taskDAVCollection+"one.ics", "", nil, 401)
auth = "Basic " + base64.StdEncoding.EncodeToString([]byte(c.Username+":"+c.Password))
s.store.DB.Exec(`UPDATE principals SET state='suspended' WHERE uuid=?`, actor)
req("GET", taskDAVCollection+"one.ics", "", nil, 401)
s.store.DB.Exec(`UPDATE principals SET state='active' WHERE uuid=?`, actor)
s.store.DB.Exec(`UPDATE organizer_dav_credentials SET expires_ms=? WHERE id=?`, time.Now().Add(-time.Hour).UnixMilli(), c.Username)
req("GET", taskDAVCollection+"one.ics", "", nil, 401)
// Revocation rechecked inside mutation transaction, not just at HTTP entry.
item, err := s.store.TaskDAVByName(ctx, domain, actor, "one.ics")
if err != nil {
t.Fatal(err)
}
item.Title = "must not save"
if _, err = s.store.SaveTaskDAV(ctx, domain, actor, item, item.Version, nil, c.Username); err != store.ErrAccessDenied {
t.Fatal(err)
}
}
func TestTaskICALValidationAndFolding(t *testing.T) {
for _, change := range []string{"RRULE:FREQ=DAILY", "DUE:20260925T100000Z", "ATTENDEE:mailto:anyone@example.test", "DURATION:PT1H", "BEGIN:VALARM\r\nACTION:DISPLAY\r\nEND:VALARM", "SUMMARY:duplicate"} {
input := strings.Replace(taskICALFixture, "END:VTODO", change+"\r\nEND:VTODO", 1)
if _, err := parseTaskICAL(input); err == nil {
t.Fatal("accepted", change)
}
}
item := newTaskRecord("task", strings.Repeat("日", 90))
item.CreatedMS = 1
item.UpdatedMS = 2
item.Version = 1
data, _, err := taskICAL(item)
if err != nil {
t.Fatal(err)
}
for _, line := range strings.Split(data, "\r\n") {
if len(line) > 75 {
t.Fatal("unfolded long line", len(line))
}
}
if _, err = parseTaskICAL(data); err != nil {
t.Fatal(err)
}
// All-day UI start=due cannot be encoded as invalid RFC VTODO dates.
item.StartOn = "2026-09-25"
item.DueOn = "2026-09-25"
data, _, err = taskICAL(item)
if err != nil {
t.Fatal(err)
}
cal, err := parseTaskICAL(data)
if err != nil {
t.Fatal(err)
}
round := taskFromICAL(cal, item)
if round.StartOn != item.StartOn {
t.Fatal("same-day start lost")
}
}
func TestTaskDAVPrivateScopeAndConcurrency(t *testing.T) {
s, token, domain, actor := taskFixture(t)
ctx := context.Background()
own, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("task", "Secret task"), 0)
if err != nil {
t.Fatal(err)
}
other, err := s.store.CreatePasswordAccount(domain, "davother", "a sufficiently long password", "Other", "")
if err != nil {
t.Fatal(err)
}
credential, password, err := s.store.CreateTaskDAVCredential(ctx, domain, other.UUID, "Other CLI", true, 1)
if err != nil {
t.Fatal(err)
}
auth := "Basic " + base64.StdEncoding.EncodeToString([]byte(credential.ID+":"+password))
p := taskDAVCollection + own.UUID + ".ics"
if w := davTaskRequest(s, auth, "GET", p, "", nil); w.Code != 404 {
t.Fatal(w.Code, w.Body)
}
if w := davTaskRequest(s, auth, "PROPFIND", taskDAVCollection, "", nil); w.Code != 207 || strings.Contains(w.Body.String(), "Secret task") {
t.Fatal(w.Code, w.Body)
}
if _, _, err = s.store.AuthenticateTaskDAV(ctx, "wrong-domain", credential.ID, password); !errors.Is(err, store.ErrAccessDenied) {
t.Fatal("cross-domain credential", err)
}
auth = "Bearer " + token
g := davTaskRequest(s, auth, "GET", p, "", nil)
if g.Code != 200 {
t.Fatal(g.Code)
}
body := strings.Replace(g.Body.String(), "SUMMARY:Secret task", "SUMMARY:Changed", 1)
var wg sync.WaitGroup
codes := make(chan int, 2)
for i := 0; i < 2; i++ {
wg.Add(1)
go func() {
defer wg.Done()
codes <- davTaskRequest(s, auth, "PUT", p, body, map[string]string{"If-Match": g.Header().Get("ETag")}).Code
}()
}
wg.Wait()
close(codes)
counts := map[int]int{}
for code := range codes {
counts[code]++
}
if counts[204] != 1 || counts[412] != 1 {
t.Fatal("CAS", counts)
}
// Extension kill switch applies to discovery, reads and writes alike.
if err = s.store.SetConfigInDomain(domain, "system_extension_states", `{"organizer.tasks":false}`); err != nil {
t.Fatal(err)
}
if w := davTaskRequest(s, auth, "PROPFIND", taskDAVRoot, "", nil); w.Code != 404 {
t.Fatal(w.Code, w.Body)
}
}
func TestTaskDAVCollectionNeverTruncates(t *testing.T) {
s, token, domain, actor := taskFixture(t)
// Synthetic DB-only rows exercise the listing guard without expensive CAS writes.
_, err := s.store.DB.Exec(`WITH RECURSIVE n(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM n WHERE x<10001)
INSERT INTO organizer_items(domain_uuid,owner_uuid,uuid,kind,project_uuid,title,status,bucket,due_on,planned_on,review_on,archived,version,created_at_ms,updated_at_ms,data,document_hash)
SELECT ?,?,'fixture-'||x,'task','','Fixture','todo','inbox','','','',0,1,x,x,'{}','' FROM n`, domain, actor)
if err != nil {
t.Fatal(err)
}
w := davTaskRequest(s, "Bearer "+token, "PROPFIND", taskDAVCollection, "", nil)
if w.Code != 507 || strings.Contains(w.Body.String(), "multistatus") {
t.Fatal("partial listing would imply deletions", w.Code, w.Body)
}
}