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

@@ -0,0 +1,177 @@
package store
import (
"database/sql"
"errors"
"strings"
"testing"
)
func externalBindingFixture(t *testing.T) *Store {
t.Helper()
database, err := sql.Open("sqlite", ":memory:")
if err != nil {
t.Fatal(err)
}
database.SetMaxOpenConns(1)
t.Cleanup(func() { database.Close() })
st := &Store{DB: database, authKey: make([]byte, 32)}
if err := st.EnsureAuthSchema(); err != nil {
t.Fatal(err)
}
if _, err := database.Exec(`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES('first','First User','same@example.test','active',1,1),('second','Second User','SAME@example.test','readonly',1,1);
INSERT INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES('i1','first','password','first',1),('i2','second','password','second',1);
INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES('m1','domain','first','active',1),('m2','domain','second','suspended',1),('m3','other','second','active',1)`); err != nil {
t.Fatal(err)
}
return st
}
func TestExternalUsernameLookupRequiresActiveAccountAndMembership(t *testing.T) {
st := externalBindingFixture(t)
principal, err := st.PrincipalByExternalUsername("domain", " FIRST ")
if err != nil || principal.UUID != "first" || principal.Username != "first" {
t.Fatalf("active username: %#v %v", principal, err)
}
if _, err := st.PrincipalByExternalUsername("domain", "second"); !errors.Is(err, ErrAccessDenied) {
t.Fatalf("suspended membership resolved username: %v", err)
}
if _, err := st.DB.Exec(`UPDATE principals SET state='quarantined' WHERE uuid='second'`); err != nil {
t.Fatal(err)
}
if _, err := st.PrincipalByExternalUsername("other", "second"); !errors.Is(err, ErrAccessDenied) {
t.Fatalf("quarantined account resolved username: %v", err)
}
if _, err := st.PrincipalByExternalUsername("domain", " "); !errors.Is(err, ErrAccessDenied) {
t.Fatal("empty username resolved account")
}
}
func TestExternalDisplayNameLookupRequiresExactUniqueActiveMembership(t *testing.T) {
st := externalBindingFixture(t)
principal, err := st.PrincipalByDisplayName("domain", " First User ")
if err != nil || principal.UUID != "first" {
t.Fatalf("unique active display name: %#v %v", principal, err)
}
if _, err := st.PrincipalByDisplayName("domain", "first user"); !errors.Is(err, ErrAccessDenied) {
t.Fatalf("case-insensitive display name unexpectedly matched: %v", err)
}
if _, err := st.DB.Exec(`UPDATE principals SET display_name='First User' WHERE uuid='second'; UPDATE domain_memberships SET state='active' WHERE uuid='m2'`); err != nil {
t.Fatal(err)
}
if principal, err := st.PrincipalByDisplayName("domain", "First User"); !errors.Is(err, ErrAccessDenied) || principal != nil {
t.Fatalf("ambiguous display name selected an arbitrary account: %#v %v", principal, err)
}
if _, err := st.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE uuid='m2'`); err != nil {
t.Fatal(err)
}
if principal, err := st.PrincipalByDisplayName("domain", "First User"); err != nil || principal.UUID != "first" {
t.Fatalf("inactive duplicate blocked unique active account: %#v %v", principal, err)
}
if _, err := st.PrincipalByDisplayName("domain", " "); !errors.Is(err, ErrAccessDenied) {
t.Fatal("empty display name resolved account")
}
}
func TestExternalEmailLookupRequiresUniqueActiveMembership(t *testing.T) {
st := externalBindingFixture(t)
principal, err := st.PrincipalByVerifiedEmail("domain", " SAME@example.test ")
if err != nil || principal.UUID != "first" {
t.Fatalf("unique active account: %#v %v", principal, err)
}
if _, err := st.DB.Exec(`UPDATE domain_memberships SET state='active' WHERE uuid='m2'`); err != nil {
t.Fatal(err)
}
if principal, err := st.PrincipalByVerifiedEmail("domain", "same@example.test"); !errors.Is(err, ErrAccessDenied) || principal != nil {
t.Fatalf("ambiguous email selected an arbitrary account: %#v %v", principal, err)
}
if _, err := st.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE domain_uuid='domain'`); err != nil {
t.Fatal(err)
}
if _, err := st.PrincipalByVerifiedEmail("domain", "same@example.test"); !errors.Is(err, ErrAccessDenied) {
t.Fatalf("suspended membership resolved email: %v", err)
}
if _, err := st.PrincipalByVerifiedEmail("other", "same@example.test"); err != nil {
t.Fatalf("readonly active member rejected: %v", err)
}
if _, err := st.DB.Exec(`UPDATE principals SET state='quarantined' WHERE uuid='second'`); err != nil {
t.Fatal(err)
}
if _, err := st.PrincipalByVerifiedEmail("other", "same@example.test"); !errors.Is(err, ErrAccessDenied) {
t.Fatal("quarantined account resolved email")
}
if _, err := st.PrincipalByVerifiedEmail("domain", " "); !errors.Is(err, ErrAccessDenied) {
t.Fatal("empty email resolved account")
}
}
func TestExternalIdentityConflictCannotRebindPrincipal(t *testing.T) {
st := externalBindingFixture(t)
bind := func(principal, marker string) error {
return st.BindExternalIdentity(principal, "oidc", "provider", "https://issuer.example.test", "subject", map[string]string{"marker": marker})
}
if err := bind("first", "initial"); err != nil {
t.Fatal(err)
}
if err := bind("second", "attacker"); !errors.Is(err, ErrAccessDenied) {
t.Fatalf("different principal rebind succeeded: %v", err)
}
var owner, attributes string
if err := st.DB.QueryRow(`SELECT principal_uuid,attributes_json FROM principal_identities WHERE provider_type='oidc'`).Scan(&owner, &attributes); err != nil {
t.Fatal(err)
}
if owner != "first" || strings.Contains(attributes, "attacker") {
t.Fatal("rejected rebind changed owner or attributes")
}
if err := bind("first", "refreshed"); err != nil {
t.Fatalf("same principal refresh rejected: %v", err)
}
principal, err := st.PrincipalByExternalIdentity("domain", "oidc", "provider", "https://issuer.example.test", "subject")
if err != nil || principal.UUID != "first" {
t.Fatalf("bound principal: %#v %v", principal, err)
}
if _, err := st.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE uuid='m1'`); err != nil {
t.Fatal(err)
}
if _, err := st.PrincipalByExternalIdentity("domain", "oidc", "provider", "https://issuer.example.test", "subject"); err == nil {
t.Fatal("suspended membership resolved external identity")
}
}
func TestExternalIdentityConcurrentBindingHasOneWinner(t *testing.T) {
st := externalBindingFixture(t)
start := make(chan struct{})
type result struct {
principal string
err error
}
results := make(chan result, 2)
for _, principal := range []string{"first", "second"} {
go func(principal string) {
<-start
results <- result{principal, st.BindExternalIdentity(principal, "oidc", "provider", "https://issuer.example.test", "race", map[string]string{"principal": principal})}
}(principal)
}
close(start)
winner, failures := "", 0
for range 2 {
result := <-results
if result.err == nil {
if winner != "" {
t.Fatal("two accounts accepted the same external subject")
}
winner = result.principal
} else if errors.Is(result.err, ErrAccessDenied) {
failures++
} else {
t.Fatal(result.err)
}
}
if winner == "" || failures != 1 {
t.Fatal("binding did not have exactly one accepted owner")
}
var actual string
if err := st.DB.QueryRow(`SELECT principal_uuid FROM principal_identities WHERE subject='race'`).Scan(&actual); err != nil || actual != winner {
t.Fatalf("binding winner was not persisted: %q %v", actual, err)
}
}