feat(storage): add native PostgreSQL runtime and verified offline application import
Build and publish container images / images (push) Failing after 12m29s
Build and publish container images / images (push) Failing after 12m29s
This commit is contained in:
1 parent
96065d1e89
commit
0ba1dcfef0
243 files changed
+21441
-3090
No files matched your search
@@ -0,0 +1,255 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"pageswiki/internal/geduldh"
|
||||
"pageswiki/internal/metadata"
|
||||
)
|
||||
|
||||
func TestRevisionBackendPipeline(t *testing.T) {
|
||||
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
|
||||
t.Run(fmt.Sprint(b), func(t *testing.T) {
|
||||
f := newPublicationBackend(t, b)
|
||||
s := f.s
|
||||
s.DocumentRoot = t.TempDir()
|
||||
ctx := context.Background()
|
||||
object, err := s.CreatePageAtPathInDomain(f.domain, "/revision-test")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
empty := ""
|
||||
base, err := s.SaveRevisionContentInDomain(ctx, f.domain, f.actor, object, []byte("base"), "first", "ja", "text/plain", "test.txt", &empty)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = s.SaveRevisionContentIfHead(object, []byte("stale"), "", "ja", "text/plain", "", ""); !errors.Is(err, ErrRevisionConflict) {
|
||||
t.Fatal("stale head", err)
|
||||
}
|
||||
if b == storePostgreSQL {
|
||||
if _, err = s.SaveRevisionContentInDomain(ctx, "outside", f.actor, object, []byte("outside"), "", "ja", "text/plain", "", nil); !errors.Is(err, ErrPageNotFound) {
|
||||
t.Fatal("foreign domain", err)
|
||||
}
|
||||
}
|
||||
en, err := s.SaveRevisionContentIfHead(object, []byte("English"), "english", "en", "text/plain", "en.txt", "")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
read, err := s.GetRevision(base.UUID)
|
||||
if err != nil || read.Body != "base" || read.Language != "ja" {
|
||||
t.Fatal(read, err)
|
||||
}
|
||||
head, err := s.GetLatestRevisionMetadataForLanguages(object, []string{"en"})
|
||||
if err != nil || head.UUID != en.UUID || head.Body != "" {
|
||||
t.Fatal(head, err)
|
||||
}
|
||||
missing, err := s.GetRevisionForExactLanguage(object, "fr")
|
||||
if err != nil || missing.UUID != "" {
|
||||
t.Fatal(missing, err)
|
||||
}
|
||||
// Distinct Store instances exercise the database CAS, not one Go mutex.
|
||||
peer := &Store{DB: s.DB, sqlBackend: b, DocumentRoot: s.DocumentRoot}
|
||||
result := make(chan error, 2)
|
||||
for _, writer := range []*Store{s, peer} {
|
||||
go func(writer *Store) {
|
||||
_, e := writer.SaveRevisionContentIfHead(object, []byte("next"), "next", "ja", "text/plain", "test.txt", base.UUID)
|
||||
result <- e
|
||||
}(writer)
|
||||
}
|
||||
wins := 0
|
||||
for i := 0; i < 2; i++ {
|
||||
e := <-result
|
||||
if e == nil {
|
||||
wins++
|
||||
} else if !errors.Is(e, ErrRevisionConflict) {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
if wins != 1 {
|
||||
t.Fatal("CAS winners", wins)
|
||||
}
|
||||
revisions, err := s.ListRevisions(object)
|
||||
if err != nil || len(revisions) != 3 {
|
||||
t.Fatal(len(revisions), err)
|
||||
}
|
||||
page, err := s.ListRevisionPage(ctx, object, "", 1)
|
||||
if err != nil || len(page.Items) != 1 || page.Next == "" {
|
||||
t.Fatal(page, err)
|
||||
}
|
||||
page2, err := s.ListRevisionPage(ctx, object, page.Next, 10)
|
||||
if err != nil || len(page2.Items) != 2 || page2.Items[0].UUID == page.Items[0].UUID {
|
||||
t.Fatal(page2, err)
|
||||
}
|
||||
var count int
|
||||
if err = s.DB.QueryRow(`SELECT count(*) FROM activity_outbox WHERE target_kind='page' AND event_type='page.created'`).Scan(&count); err != nil || count != 1 {
|
||||
t.Fatal("missing page creation event", count, err)
|
||||
}
|
||||
if err = s.DB.QueryRow(`SELECT count(*) FROM activity_outbox WHERE target_kind='revision' AND event_type='revision.created'`).Scan(&count); err != nil || count != 3 {
|
||||
t.Fatal("partial or missing outbox", count, err)
|
||||
}
|
||||
// An outbox failure rolls back the Revision; a pre-persisted orphan blob
|
||||
// may remain and must never be deleted by the failed writer.
|
||||
if _, err = s.DB.Exec(`ALTER TABLE activity_outbox RENAME COLUMN payload TO unavailable_payload`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = s.SaveRevisionContent(object, []byte("must roll back"), "", "ja", "text/plain", ""); err == nil {
|
||||
t.Fatal("outbox failure ignored")
|
||||
}
|
||||
if _, err = s.CreatePageAtPathInDomain(f.domain, "/rollback-create"); err == nil {
|
||||
t.Fatal("page creation ignored outbox failure")
|
||||
}
|
||||
if err = s.DB.QueryRow(`SELECT count(*) FROM paths WHERE path='/rollback-create'`).Scan(&count); err != nil || count != 0 {
|
||||
t.Fatal("partial page creation", count, err)
|
||||
}
|
||||
revisions, err = s.ListRevisions(object)
|
||||
if err != nil || len(revisions) != 3 {
|
||||
t.Fatal("partial revision", len(revisions), err)
|
||||
}
|
||||
if b == storePostgreSQL {
|
||||
var cached string
|
||||
if err = s.DB.QueryRow(`SELECT body FROM revisions WHERE uuid=$1`, base.UUID).Scan(&cached); err != nil || cached != "" {
|
||||
t.Fatal("native body cache", cached, err)
|
||||
}
|
||||
key, _ := geduldh.Key(base.DocumentHash)
|
||||
if err = os.Remove(filepath.Join(s.DocumentRoot, key)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = s.GetRevision(base.UUID); !errors.Is(err, os.ErrNotExist) {
|
||||
t.Fatal("missing canonical body was hidden", err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestPostgreSQLRevisionAssetDomainAndMissingPayload(t *testing.T) {
|
||||
f := newPublicationBackend(t, storePostgreSQL)
|
||||
s := f.s
|
||||
s.DocumentRoot = t.TempDir()
|
||||
ctx := context.Background()
|
||||
repo, _ := metadata.New(s.DB, metadata.PostgreSQL)
|
||||
object, err := repo.CreatePage(ctx, f.domain, "/asset-revision")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
hash := revisionHash("image")
|
||||
if err = s.persistDocument(hash, "image"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
_, err = repo.PutAsset(ctx, metadata.Asset{DomainUUID: f.domain, Address: "asset:image:cover", HeadDocumentHash: hash, ContentType: "image/png", SizeBytes: 5}, "", f.actor)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
base, err := s.SaveRevisionContent(object, []byte(`<img src="asset:image:cover">`), "", "und", "text/html", "")
|
||||
if err != nil || !strings.Contains(base.Body, hash) {
|
||||
t.Fatal(base, err)
|
||||
}
|
||||
var refs int
|
||||
if err = s.DB.QueryRow(`SELECT count(*) FROM revision_document_refs WHERE revision_uuid=$1 AND document_hash=$2`, base.UUID, hash).Scan(&refs); err != nil || refs != 1 {
|
||||
t.Fatal(refs, err)
|
||||
}
|
||||
linked, err := s.DocumentReferencesInDomain(f.domain, hash)
|
||||
if err != nil || len(linked) == 0 || linked[0].Path != "/asset-revision" {
|
||||
t.Fatal(linked, err)
|
||||
}
|
||||
// Move the mutable asset HEAD; restoration must keep the old image hash.
|
||||
newHash := revisionHash("new image")
|
||||
if err = s.persistDocument(newHash, "new image"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
_, err = repo.PutAsset(ctx, metadata.Asset{DomainUUID: f.domain, Address: "asset:image:cover", HeadDocumentHash: newHash, ContentType: "image/png", SizeBytes: 9}, hash, f.actor)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
restored, err := s.RestoreRevisionInDomain(ctx, f.domain, f.actor, base.UUID, base.UUID, "restore historical")
|
||||
if err != nil || restored.UUID == base.UUID || restored.DocumentHash != base.DocumentHash {
|
||||
t.Fatal(restored, err)
|
||||
}
|
||||
if err = s.DB.QueryRow(`SELECT count(*) FROM revision_document_refs WHERE revision_uuid=$1 AND document_hash=$2`, restored.UUID, hash).Scan(&refs); err != nil || refs != 1 {
|
||||
t.Fatal("restored refs", refs, err)
|
||||
}
|
||||
if _, err = s.RestoreRevisionInDomain(ctx, f.domain, f.actor, base.UUID, base.UUID, "stale restore"); !errors.Is(err, ErrRevisionConflict) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
f.exec(`INSERT INTO paths(domain_uuid,path,object_uuid,created_at) VALUES($1,'/foreign',$2,1)`, "outside", object)
|
||||
if _, err = s.SaveRevisionContent(object, []byte("ambiguous"), "", "und", "text/plain", ""); !errors.Is(err, ErrRevisionDomainRequired) {
|
||||
t.Fatal("ambiguous default domain", err)
|
||||
}
|
||||
if _, err = s.SaveRevisionContentInDomain(ctx, f.domain, f.actor, object, []byte("explicit"), "", "und", "text/plain", "", nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
key, _ := geduldh.Key(hash)
|
||||
if err = os.Remove(filepath.Join(s.DocumentRoot, key)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = s.RestoreRevisionInDomain(ctx, f.domain, f.actor, base.UUID, restored.UUID, "unavailable image"); err == nil {
|
||||
t.Fatal("missing historical payload accepted")
|
||||
}
|
||||
key, _ = geduldh.Key(newHash)
|
||||
if err = os.Remove(filepath.Join(s.DocumentRoot, key)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = s.SaveRevisionContentInDomain(ctx, f.domain, f.actor, object, []byte(`<img src="asset:image:cover">`), "", "und", "text/html", "", nil); err == nil {
|
||||
t.Fatal("missing embedded payload accepted")
|
||||
}
|
||||
s.ReadOnly = true
|
||||
if _, err = s.SaveRevisionContent(object, []byte("readonly"), "", "und", "text/plain", ""); !errors.Is(err, ErrReadOnly) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPostgreSQLRevisionProvenanceAndUnconditionalAppend(t *testing.T) {
|
||||
f := newPublicationBackend(t, storePostgreSQL)
|
||||
s := f.s
|
||||
s.DocumentRoot = t.TempDir()
|
||||
ctx := context.Background()
|
||||
object, err := s.CreateObjectInDomain(f.domain, "page")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
first, err := s.SaveRevisionContent(object, []byte("unbound\x00payload"), "", "und", "application/octet-stream", "file.bin")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
read, err := s.GetRevision(first.UUID)
|
||||
if err != nil || read.Body != "unbound\x00payload" {
|
||||
t.Fatal(read, err)
|
||||
}
|
||||
peer := &Store{DB: s.DB, sqlBackend: storePostgreSQL, DocumentRoot: s.DocumentRoot}
|
||||
results := make(chan *Revision, 2)
|
||||
errs := make(chan error, 2)
|
||||
for _, writer := range []*Store{s, peer} {
|
||||
go func(writer *Store) {
|
||||
v, e := writer.SaveRevisionContent(object, []byte("append"), "", "und", "text/plain", "")
|
||||
results <- v
|
||||
errs <- e
|
||||
}(writer)
|
||||
}
|
||||
for i := 0; i < 2; i++ {
|
||||
if e := <-errs; e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
a, b := <-results, <-results
|
||||
if a.UUID == b.UUID || a.CreatedAtMS == b.CreatedAtMS || a.CreatedAtMS <= first.CreatedAtMS || b.CreatedAtMS <= first.CreatedAtMS {
|
||||
t.Fatal("append ordering", a, b)
|
||||
}
|
||||
f.exec(`INSERT INTO paths(domain_uuid,path,object_uuid,created_at) VALUES('foreign','/moved',$1,1)`, object)
|
||||
if _, err = s.SaveRevisionContentInDomain(ctx, f.domain, f.actor, object, []byte("wrong origin"), "", "und", "text/plain", "", nil); !errors.Is(err, ErrPageNotFound) {
|
||||
t.Fatal("origin survived relocation", err)
|
||||
}
|
||||
if ok, err := s.ObjectInDomainAuthorityScope(f.domain, object); err != nil || ok {
|
||||
t.Fatal(ok, err)
|
||||
}
|
||||
f.exec(`DELETE FROM paths WHERE object_uuid=$1`, object)
|
||||
f.exec(`UPDATE domains SET enabled=0 WHERE uuid=$1`, f.domain)
|
||||
if _, err = s.SaveRevisionContent(object, []byte("disabled"), "", "und", "text/plain", ""); !errors.Is(err, ErrPageNotFound) {
|
||||
t.Fatal("disabled domain", err)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user