QuickandClaude Opus 5
05af63ea2b
The cross-platform settings contract needs one typed store behind it before a resolver, routes or a migration can exist. This adds that storage to both user-store backends and holds them to identical behavior. PostgreSQL gets user_setting_values with the scope CHECK constraints, the five partial unique indexes that enforce one explicit value per identity, and the covering indexes the one-query read path needs, plus user_setting_mutations for mutation_id idempotency and the inert user_setting_migration_rejects audit table. The per-user SQLite store gets the same shape minus user_id, since that database is already user-scoped. The UserStore interface grows the typed operations: read one explicit value at one scope, collect every candidate row for a resolution request in a single query, upsert with a revision increment, unset, and the idempotency receipt operations. The resolution read deliberately returns unranked candidates so the resolver can rank in Go — one query per request, never one per scope, which the pgx query-count test pins. Delete behavior is application-enforced. Neither backend can inherit it from constraints: the SQLite store declares no foreign keys, and library, series and device columns are not FK targets in Postgres either. Profile deletion cascades to profile-anchored values while account scope survives, forgetting a device clears its profile_device values alongside the legacy overrides, and the library/series purges remove only what is scoped to that entity. The shared conformance suite covers all of it, including the set-versus-unset distinction for false, 0, "" and null, so a divergence between the two backends fails a test rather than reaching a client. Part of #376 Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
64 lines
1.9 KiB
Go
64 lines
1.9 KiB
Go
package userdb
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/Silo-Server/silo-server/internal/userstore"
|
|
"github.com/Silo-Server/silo-server/internal/userstore/storetest"
|
|
)
|
|
|
|
func newConformanceStore(t *testing.T) userstore.UserStore {
|
|
t.Helper()
|
|
db, err := sql.Open("sqlite3", ":memory:")
|
|
if err != nil {
|
|
t.Fatalf("open sqlite: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = db.Close() })
|
|
if err := InitSchema(db); err != nil {
|
|
t.Fatalf("InitSchema: %v", err)
|
|
}
|
|
return NewSQLiteUserStore(db)
|
|
}
|
|
|
|
// TestSQLiteProgressSince runs the offline-sync progress-reconciliation
|
|
// conformance test (invariant 1) against the real SQLite backend, exercising the
|
|
// synced_seq stamping triggers and event_at LWW comparison.
|
|
func TestSQLiteProgressSince(t *testing.T) {
|
|
storetest.RunProgressSince(t, newConformanceStore)
|
|
}
|
|
|
|
// TestSQLiteSettingValues runs the canonical settings-contract storage
|
|
// conformance tests against the per-user SQLite backend. The Postgres backend
|
|
// runs the same suite in internal/userstore/pgstore, which is what keeps the two
|
|
// from drifting on scope identity, partial uniqueness and delete behavior.
|
|
func TestSQLiteSettingValues(t *testing.T) {
|
|
storetest.RunSettingValues(t, newConformanceStore)
|
|
}
|
|
|
|
func TestSQLiteAddFavoriteAtReportsInsertion(t *testing.T) {
|
|
ctx := context.Background()
|
|
store := newConformanceStore(t)
|
|
if err := store.CreateProfile(ctx, userstore.Profile{ID: "p1", Name: "Test"}); err != nil {
|
|
t.Fatalf("CreateProfile: %v", err)
|
|
}
|
|
|
|
addedAt := time.Date(2026, time.July, 16, 12, 0, 0, 0, time.UTC)
|
|
inserted, err := store.AddFavoriteAt(ctx, "p1", "movie-1", addedAt)
|
|
if err != nil {
|
|
t.Fatalf("first AddFavoriteAt: %v", err)
|
|
}
|
|
if !inserted {
|
|
t.Fatal("first AddFavoriteAt reported no insertion")
|
|
}
|
|
inserted, err = store.AddFavoriteAt(ctx, "p1", "movie-1", addedAt)
|
|
if err != nil {
|
|
t.Fatalf("duplicate AddFavoriteAt: %v", err)
|
|
}
|
|
if inserted {
|
|
t.Fatal("duplicate AddFavoriteAt reported an insertion")
|
|
}
|
|
}
|