213 lines
6.9 KiB
Go
213 lines
6.9 KiB
Go
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)
|
|
}
|
|
}
|