storetest

func Contains ¶

func Contains(jobs []*job.Job, jobID id.JobID) bool

Contains reports whether jobs includes the given ID.

Reclamation is not queue-scoped, so cases that exercise it must assert on the job they created rather than on the length of the returned slice — otherwise a shared store makes every such case depend on what its neighbours left behind.

func PendingJob ¶

func PendingJob(name, queue string, ttl time.Duration) *job.Job

PendingJob builds a job ready to be dequeued now, on the given queue and with the given lease TTL. A zero ttl leaves LeaseTTL unset, meaning the pool default.

The queue is a parameter because the suite may run against one shared store — spinning a fresh Postgres or Redis container per subtest would cost more than the coverage is worth — so each case dequeues from its own queue to stay isolated from its neighbours.

func RunCheckpointOrderSuite ¶

func RunCheckpointOrderSuite(t *testing.T, s workflow.Store, setTime func(context.Context, id.RunID, string, time.Time) error)

RunCheckpointOrderSuite checks the shared timestamp/ID order against actual persisted rows. setTime forces ties without depending on a backend's clock.

func RunClusterSuite ¶

func RunClusterSuite(t *testing.T, newStore func(t *testing.T) cluster.Store)

RunClusterSuite pins the worker row contract the engine's heartbeat and the dashboard's worker list rely on: a registered row reads back whole, capacity included, a heartbeat moves LastSeen to now, and both reads and heartbeats on a row that does not exist say so with dispatch.ErrWorkerNotFound. The engine re-registers on exactly that sentinel, so a backend that returned nil or another error for a missing row would leave a live worker invisible after another instance's stale sweep removed it.

newStore may return a shared store. Each case registers its own worker IDs and never asserts on ListWorkers, and no case sets IsLeader, so the single-leader index some backends keep is never contended.

func RunCronSuite ¶

func RunCronSuite(t *testing.T, newStore func(t *testing.T) CronStore)

RunCronSuite pins the targeted cron writes: each changes only the fields it names. The load-bearing case is DisableSurvivesAFire, the regression that let a disabled cron come back when the scheduler wrote its whole stale row after firing.

newStore may return a shared store, so every case registers its own entry under a unique name and never lists or counts.

func RunDLQReplaySuite ¶

func RunDLQReplaySuite(t *testing.T, newStore func(t *testing.T) DLQReplayStore)

RunDLQReplaySuite pins the replay claim: the first claim wins and every later one is refused, a release only undoes its own claim, the job a replay created reads back from every path, and a push never overwrites.

Run it with `go test -race`. ClaimReplayConcurrentExactlyOneWinner is the case that proves the claim is atomic, and an unguarded read-then-write only loses that race reliably under the detector.

newStore may return a shared store, so every case works on entries it pushed itself under a queue nobody else uses, and never asserts a total.

func RunDLQSuite ¶

func RunDLQSuite(t *testing.T, newStore func(t *testing.T) DLQStore)

RunDLQSuite asserts the DLQ contract every backend has to satisfy.

newStore may return a shared store, so every case works on entries it created itself and never asserts on the total count.

func RunDequeueSuite ¶

func RunDequeueSuite(t *testing.T, newStore func(t *testing.T) job.Store)

RunDequeueSuite runs the resource-aware dequeue conformance suite against a backend.

newStore is called once per subtest and receives that subtest's *testing.T, so a backend that stands up a container or opens a database can register teardown on the T that owns it. Closing over the parent T instead would hold every subtest's resources open until the whole suite finished, and would turn a setup t.Fatalf into a FailNow on a parent test.

newStore may return the same underlying store on every call. Each case enqueues onto its own queue and asserts only on the jobs it created, so cases cannot interfere — which matters because starting a fresh Postgres, Mongo, or Redis container per subtest would dominate the runtime of the whole suite.

func RunLeaseSuite ¶

func RunLeaseSuite(t *testing.T, newStore func(t *testing.T) LeaseStore)

RunLeaseSuite runs the lease conformance suite against a backend.

newStore is called once per subtest. It may return the same underlying store every time: each case enqueues onto its own queue and asserts on the jobs it created, so cases do not interfere. That matters because starting a fresh Postgres or Redis container per subtest would dominate the runtime of the whole suite.

The lease is GRANTED by job.Store.DequeueJobs, through job.DequeueOpts.WorkerID and LeaseUntil — there is no separate leased dequeue. That is why every case below claims with DequeueJobs: a backend cannot pass this suite with a grant path that skips the fit predicate, because there is only one path.

func RunListSuite ¶

func RunListSuite(t *testing.T, newStore func(t *testing.T) ListStore)

RunListSuite pins the paged list contract: newest first by ID, a cursor that is the last ID returned, filters that are exact except a literal case-sensitive name prefix, and an empty scope that means every tenant.

newStore may return a shared store, so each case isolates itself with a queue, name prefix or scope nobody else uses, and asserts on the identity of what comes back, never on a total.

func RunWorkflowSuite ¶

func RunWorkflowSuite(t *testing.T, newStore func(t *testing.T) WorkflowStore)

RunWorkflowSuite pins ReopenRun, the claim that makes replay-from-step safe, and the parent link child runs are found by.

Run it with `go test -race`. ReopenRunConcurrentExactlyOneWinner proves the claim is atomic, and an unguarded read-then-write only loses that race reliably under the detector.

newStore may return a shared store, so every case creates its own runs and never lists or counts anything but its own parent's children.

func RunningJob ¶

func RunningJob(name, queue string, ttl time.Duration) *job.Job

RunningJob builds a job already in the running state with an expired lease held by an unknown worker, for testing reclamation directly.