Files
kandev/apps/backend/internal/system/storage/store_test.go
T
2026-08-13 11:07:46 +01:00

489 lines
17 KiB
Go

package storage
import (
"context"
"encoding/json"
"errors"
"fmt"
"os"
"path/filepath"
"testing"
"time"
"github.com/kandev/kandev/internal/db"
"github.com/kandev/kandev/internal/testutil"
)
func TestStoreRunTransitionsSurviveRecreation(t *testing.T) {
conn := newSQLite(t)
pool := db.NewPool(conn, conn)
store := newStorageStore(t, pool)
ctx := context.Background()
run := &MaintenanceRun{
ID: "run-1",
Trigger: RunTriggerManual,
State: RunStateQueued,
SettingsSnapshot: json.RawMessage(`{"enabled":true}`),
}
if err := store.CreateRun(ctx, run); err != nil {
t.Fatalf("CreateRun: %v", err)
}
if _, err := store.TransitionRun(ctx, run.ID, RunStateRunning, nil, ""); err != nil {
t.Fatalf("transition running: %v", err)
}
store = newStorageStore(t, pool)
got, err := store.TransitionRun(ctx, run.ID, RunStateSucceeded, json.RawMessage(`{"bytes":42}`), "done")
if err != nil {
t.Fatalf("transition succeeded after recreation: %v", err)
}
if got.State != RunStateSucceeded || got.CompletedAt == nil || got.Message != "done" || string(got.Result) != `{"bytes":42}` {
t.Fatalf("completed run = %#v", got)
}
}
func TestStoreRejectsInvalidRunTransitions(t *testing.T) {
conn := newSQLite(t)
store := newStorageStore(t, db.NewPool(conn, conn))
ctx := context.Background()
if err := store.CreateRun(ctx, &MaintenanceRun{ID: "run-1", Trigger: RunTriggerScheduled, State: RunStateQueued}); err != nil {
t.Fatalf("CreateRun: %v", err)
}
if _, err := store.TransitionRun(ctx, "run-1", RunStateSucceeded, nil, ""); !errors.Is(err, ErrInvalidTransition) {
t.Fatalf("queued -> succeeded error = %v, want ErrInvalidTransition", err)
}
}
func TestStoreAllowsEveryRunStateTransition(t *testing.T) {
tests := []struct {
name string
steps []RunState
}{
{name: "busy before running", steps: []RunState{RunStateSkippedBusy}},
{name: "cancelled before running", steps: []RunState{RunStateCancelled}},
{name: "failed before running", steps: []RunState{RunStateFailed}},
{name: "succeeded", steps: []RunState{RunStateRunning, RunStateSucceeded}},
{name: "failed", steps: []RunState{RunStateRunning, RunStateFailed}},
{name: "cancelled", steps: []RunState{RunStateRunning, RunStateCancelled}},
}
for i, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
conn := newSQLite(t)
store := newStorageStore(t, db.NewPool(conn, conn))
id := fmt.Sprintf("run-%d", i)
if err := store.CreateRun(context.Background(), &MaintenanceRun{
ID: id, Trigger: RunTriggerScheduled, State: RunStateQueued,
}); err != nil {
t.Fatalf("CreateRun: %v", err)
}
for _, state := range tt.steps {
if _, err := store.TransitionRun(context.Background(), id, state, nil, ""); err != nil {
t.Fatalf("transition to %s: %v", state, err)
}
}
})
}
}
func TestStoreRunRetentionKeepsNewestTwentyTerminalAndAllNonTerminal(t *testing.T) {
conn := newSQLite(t)
store := newStorageStore(t, db.NewPool(conn, conn))
ctx := context.Background()
base := time.Date(2026, time.July, 14, 12, 0, 0, 0, time.UTC)
for i := range 25 {
run := &MaintenanceRun{
ID: fmt.Sprintf("run-%02d", i),
Trigger: RunTriggerManual,
State: RunStateQueued,
StartedAt: base.Add(time.Duration(i) * time.Minute),
}
if err := store.CreateRun(ctx, run); err != nil {
t.Fatalf("CreateRun %d: %v", i, err)
}
if _, err := store.TransitionRun(ctx, run.ID, RunStateRunning, nil, ""); err != nil {
t.Fatalf("transition running %d: %v", i, err)
}
if _, err := store.TransitionRun(ctx, run.ID, RunStateSucceeded, nil, ""); err != nil {
t.Fatalf("transition succeeded %d: %v", i, err)
}
}
for _, state := range []RunState{RunStateQueued, RunStateRunning} {
id := "active-" + string(state)
if err := store.CreateRun(ctx, &MaintenanceRun{ID: id, Trigger: RunTriggerAnalysis, State: RunStateQueued}); err != nil {
t.Fatalf("CreateRun %s: %v", id, err)
}
if state == RunStateRunning {
if _, err := store.TransitionRun(ctx, id, state, nil, ""); err != nil {
t.Fatalf("transition %s: %v", id, err)
}
}
}
var terminal, nonTerminal int
if err := conn.Get(&terminal, `SELECT COUNT(*) FROM storage_maintenance_runs WHERE state IN ('succeeded','failed','cancelled','skipped_busy')`); err != nil {
t.Fatalf("count terminal: %v", err)
}
if err := conn.Get(&nonTerminal, `SELECT COUNT(*) FROM storage_maintenance_runs WHERE state IN ('queued','running')`); err != nil {
t.Fatalf("count non-terminal: %v", err)
}
if terminal != 20 || nonTerminal != 2 {
t.Fatalf("retained terminal=%d non-terminal=%d, want 20 and 2", terminal, nonTerminal)
}
if _, err := store.GetRun(ctx, "run-00"); !errors.Is(err, ErrNotFound) {
t.Fatalf("oldest run error = %v, want ErrNotFound", err)
}
if _, err := store.GetRun(ctx, "run-24"); err != nil {
t.Fatalf("newest run missing: %v", err)
}
}
func TestStoreQuarantineTransitionsSurviveRecreation(t *testing.T) {
conn := newSQLite(t)
pool := db.NewPool(conn, conn)
store := newStorageStore(t, pool)
ctx := context.Background()
entry := &QuarantineEntry{
ID: "entry-1",
ResourceType: ResourceTypeTaskWorkspace,
TaskID: "task-1",
WorkspaceID: "workspace-1",
OriginalPath: "/tmp/tasks/task-1",
QuarantinePath: "/tmp/trash/tasks/task-1",
SizeBytes: 42,
State: QuarantineStateQuarantined,
QuarantinedAt: time.Date(2026, time.July, 14, 12, 0, 0, 0, time.UTC),
DeleteAfter: time.Date(2026, time.July, 21, 12, 0, 0, 0, time.UTC),
Metadata: json.RawMessage(`{"layout":1}`),
}
if err := store.CreateQuarantineEntry(ctx, entry); err != nil {
t.Fatalf("CreateQuarantineEntry: %v", err)
}
failed, err := store.TransitionQuarantineEntry(ctx, entry.ID, QuarantineStateFailed, "permission denied")
if err != nil {
t.Fatalf("transition failed: %v", err)
}
if failed.LastError != "permission denied" {
t.Fatalf("failed entry last_error = %q", failed.LastError)
}
store = newStorageStore(t, pool)
restored, err := store.TransitionQuarantineEntry(ctx, entry.ID, QuarantineStateRestored, "")
if err != nil {
t.Fatalf("transition restored after recreation: %v", err)
}
if restored.State != QuarantineStateRestored || restored.RestoredAt == nil || restored.LastError != "" {
t.Fatalf("restored entry = %#v", restored)
}
if _, err := store.TransitionQuarantineEntry(ctx, entry.ID, QuarantineStateDeleted, ""); !errors.Is(err, ErrInvalidTransition) {
t.Fatalf("restored -> deleted error = %v, want ErrInvalidTransition", err)
}
}
func TestStoreTemporaryArtifactLifecycleSurvivesRecreation(t *testing.T) {
conn := newSQLite(t)
pool := db.NewPool(conn, conn)
store := newStorageStore(t, pool)
ctx := context.Background()
createdAt := time.Date(2026, time.August, 1, 12, 0, 0, 0, time.UTC)
artifact := &TemporaryArtifact{
ID: "artifact-1", Kind: TemporaryArtifactKindImproveBundle,
Path: "/tmp/kandev-improve-artifact-1", MarkerToken: "marker-1",
State: TemporaryArtifactStateActive, OwnerPID: 1234,
CreatedAt: createdAt, LastHeartbeatAt: &createdAt,
Metadata: json.RawMessage(`{"owner":"user-1"}`),
}
if err := store.CreateTemporaryArtifact(ctx, artifact); err != nil {
t.Fatalf("CreateTemporaryArtifact: %v", err)
}
closedAt := createdAt.Add(time.Hour)
if err := store.TransitionTemporaryArtifact(
ctx, artifact.ID, TemporaryArtifactStateClosed, "", closedAt,
); err != nil {
t.Fatalf("close temporary artifact: %v", err)
}
if err := store.TransitionTemporaryArtifact(
ctx, artifact.ID, TemporaryArtifactStateActive, "", closedAt,
); !errors.Is(err, ErrInvalidTransition) {
t.Fatalf("closed-to-active transition error = %v, want %v", err, ErrInvalidTransition)
}
store = newStorageStore(t, pool)
got, err := store.GetTemporaryArtifact(ctx, artifact.ID)
if err != nil {
t.Fatalf("GetTemporaryArtifact after recreation: %v", err)
}
if got.State != TemporaryArtifactStateClosed || got.ClosedAt == nil ||
!got.ClosedAt.Equal(closedAt) || string(got.Metadata) != `{"owner":"user-1"}` {
t.Fatalf("temporary artifact = %#v", got)
}
}
func TestStoreQuarantineOriginalPathUniqueWhileActive(t *testing.T) {
conn := newSQLite(t)
store := newStorageStore(t, db.NewPool(conn, conn))
ctx := context.Background()
first := &QuarantineEntry{
ID: "entry-1",
ResourceType: ResourceTypeGoCache,
OriginalPath: "/tmp/go-build",
QuarantinePath: "/tmp/trash/go-build-1",
State: QuarantineStateQuarantined,
QuarantinedAt: time.Date(2026, time.July, 14, 12, 0, 0, 0, time.UTC),
DeleteAfter: time.Date(2026, time.July, 21, 12, 0, 0, 0, time.UTC),
}
if err := store.CreateQuarantineEntry(ctx, first); err != nil {
t.Fatalf("create first entry: %v", err)
}
duplicate := *first
duplicate.ID = "entry-2"
duplicate.QuarantinePath = "/tmp/trash/go-build-2"
if err := store.CreateQuarantineEntry(ctx, &duplicate); err == nil {
t.Fatal("expected duplicate active original path to fail")
}
if _, err := store.TransitionQuarantineEntry(ctx, first.ID, QuarantineStateDeleted, ""); err != nil {
t.Fatalf("delete first entry: %v", err)
}
if err := store.CreateQuarantineEntry(ctx, &duplicate); err != nil {
t.Fatalf("reuse terminal original path: %v", err)
}
}
func TestReleaseFailedQuarantineIntentRequiresProvenUnmovedState(t *testing.T) {
resourceTypes := []ResourceType{ResourceTypeTaskWorkspace, ResourceTypeGoCache}
states := []struct {
name string
originalExists bool
quarantineExists bool
wantReleased bool
}{
{name: "original remains and quarantine is absent", originalExists: true, wantReleased: true},
{name: "quarantine exists", originalExists: true, quarantineExists: true},
{name: "original is absent", quarantineExists: true},
{name: "both paths are absent"},
}
for _, resourceType := range resourceTypes {
for _, state := range states {
t.Run(string(resourceType)+"/"+state.name, func(t *testing.T) {
conn := newSQLite(t)
store := newStorageStore(t, db.NewPool(conn, conn))
root := t.TempDir()
original := filepath.Join(root, "original")
quarantine := filepath.Join(root, "quarantine")
if state.originalExists {
if err := os.Mkdir(original, 0o700); err != nil {
t.Fatalf("create original: %v", err)
}
}
if state.quarantineExists {
if err := os.Mkdir(quarantine, 0o700); err != nil {
t.Fatalf("create quarantine: %v", err)
}
}
entry := testQuarantineEntry("failed-entry")
entry.ResourceType = resourceType
entry.OriginalPath = original
entry.QuarantinePath = quarantine
if err := store.CreateQuarantineEntry(context.Background(), &entry); err != nil {
t.Fatalf("create failed intent: %v", err)
}
if _, err := store.TransitionQuarantineEntry(
context.Background(), entry.ID, QuarantineStateFailed, "rename failed",
); err != nil {
t.Fatalf("mark intent failed: %v", err)
}
released, err := ReleaseFailedQuarantineIntent(
context.Background(), store, resourceType, original,
)
if state.wantReleased {
if err != nil || !released {
t.Fatalf("ReleaseFailedQuarantineIntent = %v, %v; want true, nil", released, err)
}
} else if !errors.Is(err, ErrConflict) || released {
t.Fatalf("ReleaseFailedQuarantineIntent = %v, %v; want false, ErrConflict", released, err)
}
stored, err := store.GetQuarantineEntry(context.Background(), entry.ID)
if err != nil {
t.Fatal(err)
}
wantState := QuarantineStateFailed
if state.wantReleased {
wantState = QuarantineStateRestored
}
if stored.State != wantState {
t.Fatalf("failed intent state = %q, want %q", stored.State, wantState)
}
replacement := entry
replacement.ID = "replacement-entry"
replacement.QuarantinePath = filepath.Join(root, "replacement-quarantine")
replacement.State = QuarantineStateQuarantined
createErr := store.CreateQuarantineEntry(context.Background(), &replacement)
if state.wantReleased && createErr != nil {
t.Fatalf("create replacement intent: %v", createErr)
}
if !state.wantReleased && createErr == nil {
t.Fatal("ambiguous failed intent released unique original-path slot")
}
})
}
}
}
func TestReleaseFailedQuarantineIntentClassifiesActiveIntent(t *testing.T) {
conn := newSQLite(t)
store := newStorageStore(t, db.NewPool(conn, conn))
original := filepath.Join(t.TempDir(), "original")
entry := testQuarantineEntry("active-entry")
entry.ResourceType = ResourceTypeGoCache
entry.OriginalPath = original
entry.State = QuarantineStateQuarantined
if err := store.CreateQuarantineEntry(context.Background(), &entry); err != nil {
t.Fatalf("create active intent: %v", err)
}
_, err := ReleaseFailedQuarantineIntent(
context.Background(), store, ResourceTypeGoCache, original,
)
var activeErr *ActiveQuarantineIntentError
if !errors.As(err, &activeErr) {
t.Fatalf("ReleaseFailedQuarantineIntent error = %v, want ActiveQuarantineIntentError", err)
}
if !errors.Is(err, ErrConflict) {
t.Fatalf("ReleaseFailedQuarantineIntent error = %v, want ErrConflict", err)
}
if activeErr.OriginalPath != original {
t.Fatalf("active intent original path = %q, want %q", activeErr.OriginalPath, original)
}
}
func TestStoreAllowsEveryQuarantineStateTransition(t *testing.T) {
tests := []struct {
name string
steps []QuarantineState
}{
{name: "restored", steps: []QuarantineState{QuarantineStateRestored}},
{name: "deleted", steps: []QuarantineState{QuarantineStateDeleted}},
{name: "failed then restored", steps: []QuarantineState{QuarantineStateFailed, QuarantineStateRestored}},
{name: "failed then deleted", steps: []QuarantineState{QuarantineStateFailed, QuarantineStateDeleted}},
}
for i, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
conn := newSQLite(t)
store := newStorageStore(t, db.NewPool(conn, conn))
entry := testQuarantineEntry(fmt.Sprintf("entry-%d", i))
if err := store.CreateQuarantineEntry(context.Background(), &entry); err != nil {
t.Fatalf("CreateQuarantineEntry: %v", err)
}
for _, state := range tt.steps {
if _, err := store.TransitionQuarantineEntry(context.Background(), entry.ID, state, ""); err != nil {
t.Fatalf("transition to %s: %v", state, err)
}
}
})
}
}
func TestStoreSummarizeQuarantineCountsOnlyActiveEntries(t *testing.T) {
conn := newSQLite(t)
store := newStorageStore(t, db.NewPool(conn, conn))
ctx := context.Background()
entries := []QuarantineEntry{
testQuarantineEntry("quarantined"),
testQuarantineEntry("failed"),
testQuarantineEntry("restored"),
testQuarantineEntry("deleted"),
}
for index := range entries {
entries[index].SizeBytes = int64((index + 1) * 10)
if err := store.CreateQuarantineEntry(ctx, &entries[index]); err != nil {
t.Fatalf("CreateQuarantineEntry(%s): %v", entries[index].ID, err)
}
}
if _, err := store.TransitionQuarantineEntry(ctx, "failed", QuarantineStateFailed, "retryable"); err != nil {
t.Fatalf("transition failed: %v", err)
}
if _, err := store.TransitionQuarantineEntry(ctx, "restored", QuarantineStateRestored, ""); err != nil {
t.Fatalf("transition restored: %v", err)
}
if _, err := store.TransitionQuarantineEntry(ctx, "deleted", QuarantineStateDeleted, ""); err != nil {
t.Fatalf("transition deleted: %v", err)
}
summary, err := store.SummarizeQuarantine(ctx)
if err != nil {
t.Fatalf("SummarizeQuarantine: %v", err)
}
if summary.Count != 2 || summary.SizeBytes != 30 {
t.Fatalf("summary = %#v, want count=2 size_bytes=30", summary)
}
}
func TestStoreSummarizeQuarantineReturnsZeroWhenEmpty(t *testing.T) {
conn := newSQLite(t)
store := newStorageStore(t, db.NewPool(conn, conn))
summary, err := store.SummarizeQuarantine(context.Background())
if err != nil {
t.Fatalf("SummarizeQuarantine: %v", err)
}
if summary.Count != 0 || summary.SizeBytes != 0 {
t.Fatalf("empty summary = %#v", summary)
}
}
func TestStoreSchemaReplaySQLite(t *testing.T) {
conn := newSQLite(t)
pool := db.NewPool(conn, conn)
newStorageStore(t, pool)
newStorageStore(t, pool)
}
func TestStoreSchemaReplayPostgres(t *testing.T) {
conn := testutil.OpenIsolatedPostgres(t, testutil.PostgresDSNFromEnv(t))
pool := db.NewPool(conn, conn)
store := newStorageStore(t, pool)
ctx := context.Background()
if err := store.CreateRun(ctx, &MaintenanceRun{
ID: "postgres-run", Trigger: RunTriggerManual, State: RunStateQueued,
}); err != nil {
t.Fatalf("CreateRun: %v", err)
}
if _, err := store.TransitionRun(ctx, "postgres-run", RunStateRunning, nil, ""); err != nil {
t.Fatalf("transition running: %v", err)
}
entry := testQuarantineEntry("postgres-entry")
if err := store.CreateQuarantineEntry(ctx, &entry); err != nil {
t.Fatalf("CreateQuarantineEntry: %v", err)
}
store = newStorageStore(t, pool)
if _, err := store.TransitionRun(ctx, "postgres-run", RunStateSucceeded, nil, ""); err != nil {
t.Fatalf("transition succeeded after replay: %v", err)
}
if _, err := store.TransitionQuarantineEntry(ctx, entry.ID, QuarantineStateRestored, ""); err != nil {
t.Fatalf("transition restored after replay: %v", err)
}
}
func newStorageStore(t *testing.T, pool *db.Pool) *Store {
t.Helper()
store, err := NewStore(pool)
if err != nil {
t.Fatalf("NewStore: %v", err)
}
return store
}
func testQuarantineEntry(id string) QuarantineEntry {
return QuarantineEntry{
ID: id,
ResourceType: ResourceTypeTaskWorkspace,
OriginalPath: "/tmp/tasks/" + id,
QuarantinePath: "/tmp/trash/tasks/" + id,
State: QuarantineStateQuarantined,
QuarantinedAt: time.Date(2026, time.July, 14, 12, 0, 0, 0, time.UTC),
DeleteAfter: time.Date(2026, time.July, 21, 12, 0, 0, 0, time.UTC),
}
}