feat(storage): add native PostgreSQL runtime and verified offline application import
Build and publish container images / images (push) Failing after 12m29s

This commit is contained in:
Anya Tokugawa committed 2026-11-15 05:47:14 +09:00
1 parent 96065d1e89
commit 0ba1dcfef0
243 files changed
+21441 -3090

No files matched your search

+312
View File
@@ -0,0 +1,312 @@
package store
import (
"context"
"database/sql"
"errors"
"fmt"
"strings"
"testing"
)
func TestApprovalBackendAtomicity(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d := accountBackendStore(t, b)
ctx := context.Background()
if err := s.EnsurePublicationApprovalSchema(); err != nil {
t.Fatal(err)
}
request := ApprovalRequest{DomainUUID: d, ScopeKind: "spot", ScopeUUID: "sp", SubjectHash: strings.Repeat("a", 64), SubjectJSON: `{}`, RequesterUUID: "requester", IdempotencyKey: "same"}
type result struct {
request ApprovalRequest
inserted bool
err error
}
create := func(req ApprovalRequest) result {
tx, e := s.DB.Begin()
if e != nil {
return result{err: e}
}
defer tx.Rollback()
r, new, e := s.CreateApprovalRequestTx(tx, req)
if e == nil {
e = tx.Commit()
}
return result{r, new, e}
}
results := make(chan result, 2)
for i := 0; i < 2; i++ {
go func() { results <- create(request) }()
}
id := ""
inserted := 0
for i := 0; i < 2; i++ {
r := <-results
if r.err != nil {
t.Fatal(r.err)
}
if id != "" && id != r.request.UUID {
t.Fatal("idempotency split")
}
id = r.request.UUID
if r.inserted {
inserted++
}
}
if inserted != 1 {
t.Fatal("duplicate request", inserted)
}
if err := s.DecideApprovalRequestScoped(ctx, "outside", id, "reviewer", "approved", "", 1); !errors.Is(err, sql.ErrNoRows) {
t.Fatal("cross-domain decision", err)
}
decisions := make(chan error, 2)
for i := 0; i < 2; i++ {
go func(i int) { decisions <- s.DecideApprovalRequestScoped(ctx, d, id, fmt.Sprint(i), "approved", "", 1) }(i)
}
winners := 0
for i := 0; i < 2; i++ {
err := <-decisions
if err == nil {
winners++
} else if !errors.Is(err, ErrApprovalTransition) {
t.Fatal(err)
}
}
if winners != 1 {
t.Fatal("two approval winners", winners)
}
var count int
if err := s.DB.QueryRow(`SELECT count(*) FROM publication_decisions`).Scan(&count); err != nil || count != 1 {
t.Fatal("partial/duplicate decisions", count, err)
}
request.IdempotencyKey = "expired"
request.ExpiresAtMS = 1
r := create(request)
if r.err != nil {
t.Fatal(r.err)
}
if err := s.DecideApprovalRequestScoped(ctx, d, r.request.UUID, "reviewer", "approved", "", 1); !errors.Is(err, ErrApprovalTransition) {
t.Fatal("expired request approved", err)
}
if n, err := s.ExpireApprovalRequests(ctx, 2, 1); err != nil || n != 1 {
t.Fatal("bounded expiry", n, err)
}
request.IdempotencyKey = "rollback"
request.ExpiresAtMS = 0
r = create(request)
if r.err != nil {
t.Fatal(r.err)
}
if _, err := s.DB.Exec(`ALTER TABLE publication_decisions RENAME COLUMN justification TO unavailable_justification`); err != nil {
t.Fatal(err)
}
if err := s.DecideApprovalRequestScoped(ctx, d, r.request.UUID, "reviewer", "approved", "", 1); err == nil {
t.Fatal("missing decision persistence accepted")
}
pending, err := s.GetApprovalRequest(ctx, d, r.request.UUID)
if err != nil || pending.State != "pending" {
t.Fatal("partial approval", pending, err)
}
})
}
}
type publicationFixture struct {
s *Store
domain, actor string
t *testing.T
}
func (f publicationFixture) exec(q string, args ...any) {
f.t.Helper()
if _, err := f.s.DB.Exec(q, args...); err != nil {
f.t.Fatal(err)
}
}
func newPublicationBackend(t *testing.T, b storeSQLBackend) publicationFixture {
t.Helper()
s, d := localityBackendStore(t, b)
if err := s.ensurePublicationSchema(); err != nil {
t.Fatal(err)
}
p, err := s.BootstrapOwner(d, "owner", "synthetic publication password", "Owner", "")
if err != nil {
t.Fatal(err)
}
f := publicationFixture{s, d, p.UUID, t}
f.exec(`INSERT INTO zones(uuid,domain_uuid,kind,name,path_prefix,created_at_ms,updated_at_ms) VALUES(`+s.sqlValues(7)+`)`, "q", d, "quartier", "q", "/news_%", 1, 1)
f.exec(`INSERT INTO zones(uuid,domain_uuid,kind,parent_uuid,name,path_prefix,created_at_ms,updated_at_ms) VALUES(`+s.sqlValues(8)+`)`, "st", d, "street", "q", "st", "/news_%/st", 1, 1)
f.exec(`INSERT INTO spots(uuid,domain_uuid,name,path_prefix,created_at_ms,updated_at_ms) VALUES(`+s.sqlValues(6)+`)`, "sp", d, "sp", "/news_%/st/sp", 1, 1)
f.exec(`INSERT INTO street_spots(street_uuid,spot_uuid,created_at_ms) VALUES('st','sp',1)`)
if err = s.SetConfigInDomain(d, "authorization_mode", "enforcing"); err != nil {
t.Fatal(err)
}
for _, node := range []struct{ kind, id string }{{"domain", d}, {"quartier", "q"}, {"spot", "sp"}} {
g, e := s.CityGovernance(context.Background(), d, p.UUID, node.kind, node.id)
if e != nil {
t.Fatal(e)
}
public := "public"
_, e = s.ChangeCityGovernance(context.Background(), d, p.UUID, node.kind, node.id, CityGovernanceChange{Epoch: g.Epoch, TopologyVersion: g.TopologyVersion, Policy: &public, ConfirmRelaxation: true}, false)
if e != nil {
t.Fatal(e)
}
}
return f
}
func (f publicationFixture) page(object, path, rev string, stamp int64) {
f.exec(`INSERT INTO objects(uuid,kind,created_at) VALUES(`+f.s.sqlValues(3)+`)`, object, "page", 1)
f.exec(`INSERT INTO paths(domain_uuid,path,object_uuid,created_at) VALUES(`+f.s.sqlValues(4)+`)`, f.domain, path, object, 1)
f.revision(object, rev, stamp)
}
func (f publicationFixture) revision(object, rev string, stamp int64) {
f.exec(`INSERT INTO revisions(uuid,object_uuid,document_hash,lang,content_type,filename,created_at_ms,created_at,body) VALUES(`+f.s.sqlValues(9)+`)`, rev, object, strings.Repeat("a", 64), "ja", "text/html", "", stamp, stamp/1000, "")
}
func (f publicationFixture) approve() LocalityPublication {
f.t.Helper()
ctx := context.Background()
p, err := f.s.LocalityPublication(ctx, f.domain, f.actor, "spot", "sp", nil)
if err != nil {
f.t.Fatal(err)
}
p, err = f.s.LocalityPublication(ctx, f.domain, f.actor, "spot", "sp", &PublicationChange{PublicationVersion: p.PublicationVersion, Epoch: p.Epoch, TopologyVersion: p.TopologyVersion, ImpactToken: p.ImpactToken, Enabled: true, Confirm: true})
if err != nil {
f.t.Fatal(err)
}
return p
}
func (f publicationFixture) automatic(kind, id, mode string) {
f.t.Helper()
ctx := context.Background()
p, err := f.s.AutoPublication(ctx, f.domain, f.actor, kind, id, nil)
if err != nil {
f.t.Fatal(err)
}
_, err = f.s.AutoPublication(ctx, f.domain, f.actor, kind, id, &AutoPublicationChange{Mode: mode, Version: p.Version, Epoch: p.Epoch, TopologyVersion: p.TopologyVersion, Confirm: true, ImpactToken: p.Impact.ImpactToken})
if err != nil {
f.t.Fatal(err)
}
}
func (f publicationFixture) expect(path, revision string) {
f.t.Helper()
v, err := f.s.AnonymousRevision(context.Background(), f.domain, path, []string{"ja"})
if revision == "" {
if !errors.Is(err, sql.ErrNoRows) {
f.t.Fatalf("%s unexpectedly published: %v %v", path, v, err)
}
return
}
if err != nil || v.UUID != revision {
f.t.Fatalf("%s: %v %v want %s", path, v, err, revision)
}
}
func TestPublicationBackendManual(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
f := newPublicationBackend(t, b)
s, d := f.s, f.domain
ctx := context.Background()
path := "/news_%/st/sp/日本語"
f.page("obj", path, "r1", 1)
f.expect(path, "")
preview, err := s.LocalityPublication(ctx, d, f.actor, "spot", "sp", nil)
if err != nil || len(preview.Entries) != 1 {
t.Fatal(preview, err)
}
f.revision("obj", "r2", 2)
if _, err = s.LocalityPublication(ctx, d, f.actor, "spot", "sp", &PublicationChange{PublicationVersion: preview.PublicationVersion, Epoch: preview.Epoch, TopologyVersion: preview.TopologyVersion, ImpactToken: preview.ImpactToken, Enabled: true, Confirm: true}); !errors.Is(err, ErrPublicationImpact) {
t.Fatal("stale content approved", err)
}
approved := f.approve()
f.expect(path, "r2")
nav, err := s.PublicNavigation(ctx, d)
if err != nil || len(nav) != 1 || nav[0].Path != path {
t.Fatal(nav, err)
}
if err = s.SetConfigInDomain(d, "authorization_mode", "permissive"); err == nil {
t.Fatal("publication enforcement removed")
}
generation, err := s.NavigationGeneration(ctx)
if err != nil {
t.Fatal(err)
}
f.revision("obj", "r3", 3)
f.expect(path, "")
next, err := s.NavigationGeneration(ctx)
if err != nil || next <= generation {
t.Fatal("generation did not advance", err)
}
if _, err = s.LocalityPublication(ctx, d, f.actor, "spot", "sp", &PublicationChange{PublicationVersion: approved.PublicationVersion, Epoch: approved.Epoch, TopologyVersion: approved.TopologyVersion, Enabled: false}); err != nil {
t.Fatal("revocation", err)
}
f.approve()
f.expect(path, "r3")
f.exec(`UPDATE campuses SET enabled=0 WHERE uuid=(SELECT campus_uuid FROM domains WHERE uuid=`+s.sqlParam(1)+`)`, d)
f.expect(path, "")
f.exec(`UPDATE campuses SET enabled=1 WHERE uuid=(SELECT campus_uuid FROM domains WHERE uuid=`+s.sqlParam(1)+`)`, d)
f.expect(path, "r3")
f.exec(`INSERT INTO paths(domain_uuid,path,object_uuid,created_at) VALUES(`+s.sqlValues(4)+`)`, d, "/outside", "obj", 1)
f.expect(path, "")
nav, err = s.PublicNavigation(ctx, d)
if err != nil || len(nav) != 0 {
t.Fatal("alias did not revoke publication", nav, err)
}
if b == storePostgreSQL {
if err = s.ensurePostgreSQLPublication(ctx); err != nil {
t.Fatal(err)
}
f.exec(`ALTER TABLE revisions DISABLE TRIGGER publication_revision_changed`)
if err = s.ensurePostgreSQLPublication(ctx); err == nil {
t.Fatal("disabled guard accepted")
}
}
})
}
}
func TestPublicationBackendAutomatic(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
f := newPublicationBackend(t, b)
s, d := f.s, f.domain
ctx := context.Background()
path := "/news_%/st/sp/page"
f.page("obj", path, "r1", 1)
f.automatic("spot", "sp", "automatic")
f.expect(path, "r1")
f.revision("obj", "r2", 2)
f.expect(path, "r2")
f.page("next", "/news_%/st/sp/next", "n1", 1)
f.page("hidden", "/newsXX/st/sp/hidden", "h1", 1)
nav, err := s.PublicNavigation(ctx, d)
if err != nil || len(nav) != 2 {
t.Fatal(nav, err)
}
f.expect("/newsXX/st/sp/hidden", "")
f.expect("/u/owner", "")
f.automatic("street", "st", "required")
f.expect(path, "")
f.automatic("street", "st", "inherit")
f.expect(path, "r2")
if err = s.SetPrincipalState(d, f.actor, "suspended"); err != nil {
t.Fatal(err)
}
f.expect(path, "")
if err = s.SetPrincipalState(d, f.actor, "active"); err != nil {
t.Fatal(err)
}
f.expect(path, "r2")
g, err := s.CityGovernance(ctx, d, f.actor, "quartier", "q")
if err != nil {
t.Fatal(err)
}
private := "authenticated_acl"
if _, err = s.ChangeCityGovernance(ctx, d, f.actor, "quartier", "q", CityGovernanceChange{Epoch: g.Epoch, TopologyVersion: g.TopologyVersion, Policy: &private}, false); err != nil {
t.Fatal(err)
}
f.expect(path, "")
})
}
}