package server
import (
"context"
"encoding/base64"
"encoding/json"
"net/http/httptest"
"strings"
"testing"
"time"
"pageswiki/internal/store"
)
// Reproduce the reported OPTIONS gate, not a claim to execute the OneTask app.
// Never use real device credentials or imported calendar data in this fixture.
func TestDAVCalendarAccessCompatibility(t *testing.T) {
s, token, domain, actor := taskFixture(t)
ctx := context.Background()
repo, err := s.calendars()
if err != nil {
t.Fatal(err)
}
c, err := repo.Create(ctx, domain, actor, "Synthetic calendar")
if err != nil {
t.Fatal(err)
}
request := func(auth, method, path, body string, h map[string]string, want int) *httptest.ResponseRecorder {
t.Helper()
r := httptest.NewRequest(method, "http://localhost"+path, strings.NewReader(body))
if auth != "" {
r.Header.Set("Authorization", auth)
}
r.Header.Set("Depth", "1")
r.Header.Set("Content-Type", "text/calendar")
for k, v := range h {
r.Header.Set(k, v)
}
w := httptest.NewRecorder()
s.handler().ServeHTTP(w, r)
if w.Code != want {
t.Fatalf("%s %s: %d want %d %s", method, path, w.Code, want, w.Body)
}
return w
}
issue := func(scope string, write, compat bool) (string, string) {
t.Helper()
b, _ := json.Marshal(map[string]any{"label": "Compatibility fixture", "scope": scope, "write": write, "calendar_access_compat": compat})
w := request("Bearer "+token, "POST", davCredentialsAPI, string(b), nil, 201)
var result struct {
Username, Password string
Credential store.TaskDAVCredential
}
if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
if result.Credential.CalendarAccessCompat != compat {
t.Fatal("compatibility not persisted")
}
return "Basic " + base64.StdEncoding.EncodeToString([]byte(result.Username+":"+result.Password)), result.Username
}
strict, _ := issue("all", true, false)
compat, id := issue("all", true, true)
readOnly, _ := issue("tasks", false, true)
paths := []string{calendarDAV, strings.TrimSuffix(calendarDAV, "/"), taskDAVRoot, strings.TrimSuffix(taskDAVRoot, "/"), taskDAVCollection, strings.TrimSuffix(taskDAVCollection, "/"), calendarDAV + c.ID + "/", calendarDAV + c.ID}
for _, p := range paths {
for _, auth := range []string{strict, "Bearer " + token} {
w := request(auth, "OPTIONS", p, "", map[string]string{"User-Agent": "OneTask"}, 204)
if w.Header().Get("DAV") != "1" || w.Header().Get("X-PagesWiki-CalDAV-Profile") != "" {
t.Fatal("UA or session enabled compatibility", w.Header())
}
}
w := request(compat, "OPTIONS", p, "", nil, 204)
if w.Header().Get("DAV") != "1, calendar-access" || w.Header().Get("X-PagesWiki-CalDAV-Profile") != "limited-compatibility" || w.Header().Get("Location") != "" {
t.Fatal(p, w.Header())
}
if strings.Contains(w.Header().Get("DAV"), "calendar-schedule") || strings.Contains(w.Header().Get("Allow"), "MKCALENDAR") {
t.Fatal("unimplemented capability advertised")
}
}
// Follow the accepted gate through authenticated discovery, fetch and writes.
home := request(compat, "PROPFIND", calendarDAV, commonDAVProps, nil, 207)
if !strings.Contains(home.Body.String(), "current-user-principal") || !strings.Contains(home.Body.String(), taskDAVCollection) {
t.Fatal(home.Body)
}
col := request(readOnly, "PROPFIND", taskDAVCollection, commonDAVProps, map[string]string{"Depth": "0"}, 207)
if !strings.Contains(col.Body.String(), "current-user-privilege-set") || strings.Contains(col.Body.String(), "") {
t.Fatal("readonly privileges", col.Body)
}
col = request(compat, "PROPFIND", taskDAVCollection, commonDAVProps, map[string]string{"Depth": "0"}, 207)
if !strings.Contains(col.Body.String(), "") {
t.Fatal("missing write privilege", col.Body)
}
p := taskDAVCollection + "compat.ics"
request(compat, "PUT", p, taskICALFixture, nil, 201)
get := request(compat, "GET", p, "", nil, 200)
request(compat, "PUT", p, taskICALFixture, nil, 204)
get = request(compat, "GET", p, "", nil, 200)
request(readOnly, "PUT", p, taskICALFixture, map[string]string{"If-Match": get.Header().Get("ETag")}, 403)
changed := strings.Replace(taskICALFixture, "SUMMARY:CLI task", "SUMMARY:Compatibility update", 1)
request(compat, "PUT", p, changed, map[string]string{"If-Match": get.Header().Get("ETag")}, 204)
query := strings.Replace(commonDAVQuery, ``, ``, 1)
result := request(compat, "REPORT", taskDAVCollection, query, nil, 207)
if !strings.Contains(result.Body.String(), "Compatibility update") {
t.Fatal(result.Body)
}
// Compatibility never strips unsupported recurrence to make a write succeed.
bad := strings.Replace(changed, "END:VTODO", "RRULE:FREQ=DAILY\r\nEND:VTODO", 1)
get = request(compat, "GET", p, "", nil, 200)
request(compat, "PUT", p, bad, map[string]string{"If-Match": get.Header().Get("ETag")}, 403)
request(compat, "DELETE", p, "", map[string]string{"If-Match": get.Header().Get("ETag")}, 204)
request(readOnly, "OPTIONS", calendarDAV+c.ID+"/", "", nil, 401)
request(compat, "POST", davCredentialsAPI, `{"label":"escalate","calendar_access_compat":true}`, nil, 401)
// Another principal/domain cannot pick up this credential's compatibility.
if enabled, _ := s.store.DAVCalendarAccessCompat(ctx, domain, "someone-else", id); enabled {
t.Fatal("cross-owner flag leaked")
}
if enabled, _ := s.store.DAVCalendarAccessCompat(ctx, "other-domain", actor, id); enabled {
t.Fatal("cross-domain flag leaked")
}
if err = s.store.RevokeTaskDAVCredential(ctx, domain, actor, id); err != nil {
t.Fatal(err)
}
w := request(compat, "OPTIONS", calendarDAV, "", nil, 401)
if w.Header().Get("DAV") != "" {
t.Fatal("revoked credential advertised support")
}
var count int
if err = s.store.DB.QueryRow(`SELECT count(*) FROM organizer_dav_compat WHERE credential_id=?`, id).Scan(&count); err != nil || count != 0 {
t.Fatal("orphan compatibility row", count, err)
}
expired, expiredID := issue("all", true, true)
if _, err = s.store.DB.Exec(`UPDATE organizer_dav_credentials SET expires_ms=? WHERE id=?`, time.Now().Add(-time.Minute).UnixMilli(), expiredID); err != nil {
t.Fatal(err)
}
request(expired, "OPTIONS", calendarDAV, "", nil, 401)
}