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

+212
View File
@@ -0,0 +1,212 @@
package store
import (
"context"
"database/sql"
"errors"
"fmt"
"testing"
"time"
"github.com/google/uuid"
)
func digestBackendFixture(t *testing.T, b storeSQLBackend) (*Store, string, string, time.Time) {
t.Helper()
s, d, a := productivityBackendFixture(t, b)
now := time.Now().UTC()
_, err := s.SaveTaskPreferences(context.Background(), d, a, TaskPreferences{Complexity: 1, DigestEnabled: true, DigestTime: "00:00", Timezone: "UTC"}, now.Add(-24*time.Hour))
if err != nil {
t.Fatal(err)
}
if _, err = s.DB.Exec(`UPDATE principals SET email='synthetic@example.invalid' WHERE uuid=`+s.sqlParam(1), a); err != nil {
t.Fatal(err)
}
return s, d, a, now
}
func TestTaskDigestBackend(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d, a, now := digestBackendFixture(t, b)
ctx := context.Background()
due, err := s.DueTaskDigests(ctx, now)
if err != nil || len(due) != 1 {
t.Fatal(due, err)
}
c, err := s.ClaimTaskDigest(ctx, due[0], now)
if err != nil {
t.Fatal(err)
}
if _, err = s.ClaimTaskDigest(ctx, due[0], now); !errors.Is(err, sql.ErrNoRows) {
t.Fatal(err)
}
if email, err := s.TaskDigestRecipient(ctx, c); err != nil || email != "synthetic@example.invalid" {
t.Fatal(email, err)
}
if err = s.FinishTaskDigestReason(ctx, c, "uncertain", "transport_uncertain", now); err != nil {
t.Fatal(err)
}
input := TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID}
if _, err = s.QueueTaskDigestRetry(ctx, d, a, input, now); !errors.Is(err, ErrTaskInvalid) {
t.Fatal(err)
}
input.DuplicateAcknowledged = true
if id, err := s.QueueTaskDigestRetry(ctx, d, a, input, now); err != nil || id != input.RequestID {
t.Fatal(id, err)
}
if id, err := s.QueueTaskDigestRetry(ctx, d, a, input, now); err != nil || id != input.RequestID {
t.Fatal("receipt replay", id, err)
}
if id, err := s.TaskDigestRetryReceipt(ctx, d, a, input); err != nil || id != input.RequestID {
t.Fatal(id, err)
}
changed := input
changed.DuplicateAcknowledged = false
if _, err = s.TaskDigestRetryReceipt(ctx, d, a, changed); !errors.Is(err, ErrTaskConflict) {
t.Fatal(err)
}
queued, err := s.QueuedTaskDigests(ctx)
if err != nil || len(queued) != 1 {
t.Fatal(queued, err)
}
retry, err := s.ClaimQueuedTaskDigest(ctx, queued[0], now)
if err != nil {
t.Fatal(err)
}
if _, err = s.ClaimQueuedTaskDigest(ctx, queued[0], now); !errors.Is(err, sql.ErrNoRows) {
t.Fatal(err)
}
if err = s.FinishTaskDigestReason(ctx, c, "sent", "", now); !errors.Is(err, ErrTaskConflict) {
t.Fatal("stale worker", err)
}
if err = s.FinishTaskDigestReason(ctx, retry, "sent", "", now); err != nil {
t.Fatal(err)
}
h, err := s.TaskDigestHistory(ctx, d, a, "", 1, now)
if err != nil || len(h.Items) != 1 || h.Next == "" || h.Current == nil || h.Current.State != "sent" || h.Retries != 1 {
t.Fatal(h, err)
}
next, err := s.TaskDigestHistory(ctx, d, a, h.Next, 1, now)
if err != nil || len(next.Items) != 1 || next.Items[0].UUID == h.Items[0].UUID {
t.Fatal(next, err)
}
if last, err := s.LastTaskDigest(ctx, d, a); err != nil || last["state"] != "sent" {
t.Fatal(last, err)
}
input.RequestID = uuid.NewString()
input.ExpectedAttempt = retry.AttemptUUID
if _, err = s.QueueTaskDigestRetry(ctx, d, a, input, now); err != nil {
t.Fatal(err)
}
p, err := s.TaskPreferences(ctx, d, a)
if err != nil {
t.Fatal(err)
}
p.DigestEnabled = false
if _, err = s.SaveTaskPreferences(ctx, d, a, p, now); err != nil {
t.Fatal(err)
}
queued, err = s.QueuedTaskDigests(ctx)
if err != nil || len(queued) != 1 {
t.Fatal(queued, err)
}
if _, err = s.ClaimQueuedTaskDigest(ctx, queued[0], now); !errors.Is(err, sql.ErrNoRows) {
t.Fatal("consent", err)
}
h, err = s.TaskDigestHistory(ctx, d, a, "", 10, now)
if err != nil || h.Current.State != "cancelled" || h.Current.Reason != "consent_changed" {
t.Fatal(h, err)
}
if _, err = s.TaskDigestRecipient(ctx, retry); err == nil {
t.Fatal("recipient after opt out")
}
if n, err := s.MaintainTaskDigests(ctx, now.Add(91*24*time.Hour)); err != nil || n != 3 {
t.Fatal(n, err)
}
if _, err = s.TaskDigestRetryReceipt(ctx, d, a, input); err != nil {
t.Fatal("retention erased receipt", err)
}
if last, err := s.LastTaskDigest(ctx, d, a); err != nil || last == nil {
t.Fatal("retention erased reservation", last, err)
}
s.ReadOnly = true
if _, err = s.MaintainTaskDigests(ctx, now); !errors.Is(err, ErrReadOnly) {
t.Fatal(err)
}
})
}
}
func TestPostgreSQLDigestConcurrencyAndRollback(t *testing.T) {
s, d, a, now := digestBackendFixture(t, storePostgreSQL)
ctx := context.Background()
peer := &Store{DB: s.DB, sqlBackend: storePostgreSQL}
claims := make(chan TaskDigestClaim, 2)
errs := make(chan error, 2)
for _, worker := range []*Store{s, peer} {
go func(w *Store) { c, e := w.ClaimTaskDigest(ctx, TaskDigestDue{d, a}, now); claims <- c; errs <- e }(worker)
}
var c TaskDigestClaim
winners := 0
for i := 0; i < 2; i++ {
got := <-claims
if got.AttemptUUID != "" {
c = got
}
err := <-errs
if err == nil {
winners++
} else if !errors.Is(err, sql.ErrNoRows) {
t.Fatal(err)
}
}
if winners != 1 {
t.Fatal(winners)
}
if _, err := s.DB.Exec(`ALTER TABLE organizer_digest_attempts RENAME COLUMN reason TO unavailable_reason`); err != nil {
t.Fatal(err)
}
if err := s.FinishTaskDigestReason(ctx, c, "sent", "", now); err == nil {
t.Fatal("injected failure accepted")
}
if _, err := s.DB.Exec(`ALTER TABLE organizer_digest_attempts RENAME COLUMN unavailable_reason TO reason`); err != nil {
t.Fatal(err)
}
if last, err := s.LastTaskDigest(ctx, d, a); err != nil || last["state"] != "sending" {
t.Fatal("partial finish", last, err)
}
if _, err := s.MaintainTaskDigests(ctx, now.Add(11*time.Minute)); err != nil {
t.Fatal(err)
}
h, err := s.TaskDigestHistory(ctx, d, a, "", 10, now)
if err != nil || h.Current.State != "uncertain" || h.Current.Reason != "worker_interrupted" {
t.Fatal(h, err)
}
if queued, err := s.QueuedTaskDigests(ctx); err != nil || len(queued) != 0 {
t.Fatal("automatic retry", queued, err)
}
input := TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID, DuplicateAcknowledged: true}
if _, err = s.QueueTaskDigestRetry(ctx, d, a, input, now); err != nil {
t.Fatal(err)
}
queued, err := s.QueuedTaskDigests(ctx)
if err != nil || len(queued) != 1 {
t.Fatal(queued, err)
}
for _, worker := range []*Store{s, peer} {
go func(w *Store) { _, e := w.ClaimQueuedTaskDigest(ctx, queued[0], now); errs <- e }(worker)
}
winners = 0
for i := 0; i < 2; i++ {
err := <-errs
if err == nil {
winners++
} else if !errors.Is(err, sql.ErrNoRows) {
t.Fatal(err)
}
}
if winners != 1 {
t.Fatal(winners)
}
}