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) } }