Files
kandev/apps/backend/internal/backendapp/storage_inventory_test.go
T

302 lines
9.4 KiB
Go

package backendapp
import (
"context"
"path/filepath"
"reflect"
"testing"
"time"
"github.com/jmoiron/sqlx"
_ "github.com/mattn/go-sqlite3"
"github.com/kandev/kandev/internal/task/models"
v1 "github.com/kandev/kandev/pkg/api/v1"
)
func TestWorkspaceInventoryOnlyProtectsActiveTaskEnvironments(t *testing.T) {
database := newContainerInventoryDatabase(t)
insertContainerInventoryTask(t, database, "active", v1.TaskStateInProgress, false)
insertContainerInventoryTask(t, database, "archived", v1.TaskStateInProgress, true)
insertContainerInventoryTask(t, database, "borrowed-owner", v1.TaskStateInProgress, true)
insertContainerInventoryTask(t, database, "borrower", v1.TaskStateInProgress, false)
for _, item := range []struct {
taskID string
path string
}{
{taskID: "active", path: "/tasks/active_abc"},
{taskID: "archived", path: "/tasks/archived_def"},
{taskID: "borrowed-owner", path: "/tasks/borrowed_jkl"},
{taskID: "deleted", path: "/tasks/deleted_ghi"},
} {
if _, err := database.Exec(
"INSERT INTO task_environments (id, task_id, status, workspace_path) VALUES (?, ?, ?, ?)",
"env-"+item.taskID, item.taskID, models.TaskEnvironmentStatusReady, item.path,
); err != nil {
t.Fatalf("insert task environment for %q: %v", item.taskID, err)
}
}
if _, err := database.Exec(
"INSERT INTO task_sessions (id, task_id, state, task_environment_id) VALUES (?, ?, ?, ?)",
"session-borrower", "borrower", models.TaskSessionStateRunning, "env-borrowed-owner",
); err != nil {
t.Fatalf("insert borrowed environment session: %v", err)
}
rows, err := (&storageInventory{reader: database}).activeWorkspaceRows(context.Background())
if err != nil {
t.Fatalf("activeWorkspaceRows: %v", err)
}
want := []activeWorkspaceRow{
{TaskID: "active", WorkspaceID: "workspace-active", WorkspacePath: "/tasks/active_abc"},
{
TaskID: "borrowed-owner", WorkspaceID: "workspace-borrowed-owner",
WorkspacePath: "/tasks/borrowed_jkl",
},
}
if !reflect.DeepEqual(rows, want) {
t.Fatalf("active workspace rows = %#v, want %#v", rows, want)
}
}
func TestWorkspaceInventoryOnlyProtectsActiveTaskWorktrees(t *testing.T) {
database := newContainerInventoryDatabase(t)
insertContainerInventoryTask(t, database, "active", v1.TaskStateInProgress, false)
insertContainerInventoryTask(t, database, "archived", v1.TaskStateInProgress, true)
for _, item := range []struct {
taskID string
path string
}{
{taskID: "active", path: "/tasks/active_abc/repo"},
{taskID: "archived", path: "/tasks/archived_def/repo"},
{taskID: "deleted", path: "/tasks/deleted_ghi/repo"},
} {
sessionID := "session-" + item.taskID
if _, err := database.Exec(
"INSERT INTO task_sessions (id, task_id) VALUES (?, ?)", sessionID, item.taskID,
); err != nil {
t.Fatalf("insert task session for %q: %v", item.taskID, err)
}
if _, err := database.Exec(
"INSERT INTO task_session_worktrees (id, session_id, status, worktree_path) VALUES (?, ?, 'active', ?)",
"worktree-"+item.taskID, sessionID, item.path,
); err != nil {
t.Fatalf("insert task worktree for %q: %v", item.taskID, err)
}
}
paths, err := (&storageInventory{reader: database}).activeWorktreePaths(context.Background())
if err != nil {
t.Fatalf("activeWorktreePaths: %v", err)
}
want := []string{"/tasks/active_abc/repo"}
if !reflect.DeepEqual(paths, want) {
t.Fatalf("active worktree paths = %#v, want %#v", paths, want)
}
}
func TestContainerInventoryRemovability(t *testing.T) {
tests := []struct {
name string
taskID string
setup func(*testing.T, *sqlx.DB)
want bool
}{
{
name: "missing task is removable",
taskID: "missing",
want: true,
},
{
name: "nonterminal task with stopped environment is retained",
taskID: "active-stopped-env",
setup: func(t *testing.T, database *sqlx.DB) {
insertContainerInventoryTask(t, database, "active-stopped-env", v1.TaskStateInProgress, false)
insertContainerInventoryEnvironment(t, database, "active-stopped-env", models.TaskEnvironmentStatusStopped)
},
},
{
name: "archived task without live handles is removable",
taskID: "archived",
setup: func(t *testing.T, database *sqlx.DB) {
insertContainerInventoryTask(t, database, "archived", v1.TaskStateInProgress, true)
},
want: true,
},
{
name: "terminal task without live handles is removable",
taskID: "terminal",
setup: func(t *testing.T, database *sqlx.DB) {
insertContainerInventoryTask(t, database, "terminal", v1.TaskStateCompleted, false)
},
want: true,
},
{
name: "terminal task with live environment is retained",
taskID: "terminal-live-env",
setup: func(t *testing.T, database *sqlx.DB) {
insertContainerInventoryTask(t, database, "terminal-live-env", v1.TaskStateCompleted, false)
insertContainerInventoryEnvironment(t, database, "terminal-live-env", models.TaskEnvironmentStatusReady)
},
},
{
name: "terminal task with unknown environment state is retained",
taskID: "terminal-unknown-env",
setup: func(t *testing.T, database *sqlx.DB) {
insertContainerInventoryTask(t, database, "terminal-unknown-env", v1.TaskStateCompleted, false)
insertContainerInventoryEnvironment(t, database, "terminal-unknown-env", "new-state")
},
},
{
name: "archived task with live executor handle is retained",
taskID: "archived-live-executor",
setup: func(t *testing.T, database *sqlx.DB) {
insertContainerInventoryTask(t, database, "archived-live-executor", v1.TaskStateCompleted, true)
insertContainerInventoryExecutor(t, database, "archived-live-executor", models.ExecutorRunningStatusRunning)
},
},
{
name: "terminal task with stopped executor is removable",
taskID: "terminal-stopped-executor",
setup: func(t *testing.T, database *sqlx.DB) {
insertContainerInventoryTask(t, database, "terminal-stopped-executor", v1.TaskStateFailed, false)
insertContainerInventoryExecutor(t, database, "terminal-stopped-executor", models.ExecutorRunningStatusStopped)
},
want: true,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
database := newContainerInventoryDatabase(t)
if test.setup != nil {
test.setup(t, database)
}
got, err := (&containerInventory{reader: database}).ContainerTaskRemovable(
context.Background(), test.taskID,
)
if err != nil {
t.Fatalf("ContainerTaskRemovable: %v", err)
}
if got != test.want {
t.Fatalf("ContainerTaskRemovable = %v, want %v", got, test.want)
}
})
}
}
func TestContainerInventoryFailsClosedWhenInventoryUnavailable(t *testing.T) {
database := newContainerInventoryDatabase(t)
insertContainerInventoryTask(t, database, "inventory-error", v1.TaskStateCompleted, false)
if err := database.Close(); err != nil {
t.Fatalf("close inventory database: %v", err)
}
removable, err := (&containerInventory{reader: database}).ContainerTaskRemovable(
context.Background(), "inventory-error",
)
if err == nil {
t.Fatal("ContainerTaskRemovable error = nil, want inventory error")
}
if removable {
t.Fatal("ContainerTaskRemovable = true on inventory error, want fail-closed false")
}
}
func newContainerInventoryDatabase(t *testing.T) *sqlx.DB {
t.Helper()
database, err := sqlx.Open("sqlite3", filepath.Join(t.TempDir(), "inventory.db"))
if err != nil {
t.Fatalf("open inventory database: %v", err)
}
database.SetMaxOpenConns(1)
t.Cleanup(func() { _ = database.Close() })
const schema = `
CREATE TABLE tasks (
id TEXT PRIMARY KEY,
state TEXT NOT NULL,
workspace_id TEXT NOT NULL DEFAULT '',
archived_at TIMESTAMP
);
CREATE TABLE task_environments (
id TEXT PRIMARY KEY,
task_id TEXT NOT NULL,
status TEXT NOT NULL,
workspace_path TEXT NOT NULL DEFAULT ''
);
CREATE TABLE task_sessions (
id TEXT PRIMARY KEY,
task_id TEXT NOT NULL,
state TEXT NOT NULL DEFAULT 'CREATED',
task_environment_id TEXT NOT NULL DEFAULT ''
);
CREATE TABLE task_session_worktrees (
id TEXT PRIMARY KEY,
session_id TEXT NOT NULL,
status TEXT NOT NULL,
worktree_path TEXT NOT NULL DEFAULT '',
deleted_at TIMESTAMP
);
CREATE TABLE executors_running (
id TEXT PRIMARY KEY,
task_id TEXT NOT NULL,
status TEXT NOT NULL,
runtime TEXT NOT NULL
);`
if _, err := database.Exec(schema); err != nil {
t.Fatalf("create inventory schema: %v", err)
}
return database
}
func insertContainerInventoryTask(
t *testing.T,
database *sqlx.DB,
taskID string,
state v1.TaskState,
archived bool,
) {
t.Helper()
var archivedAt any
if archived {
archivedAt = time.Now().UTC()
}
if _, err := database.Exec(
"INSERT INTO tasks (id, state, workspace_id, archived_at) VALUES (?, ?, ?, ?)",
taskID, state, "workspace-"+taskID, archivedAt,
); err != nil {
t.Fatalf("insert task %q: %v", taskID, err)
}
}
func insertContainerInventoryEnvironment(
t *testing.T,
database *sqlx.DB,
taskID string,
status models.TaskEnvironmentStatus,
) {
t.Helper()
if _, err := database.Exec(
"INSERT INTO task_environments (id, task_id, status) VALUES (?, ?, ?)",
"env-"+taskID, taskID, status,
); err != nil {
t.Fatalf("insert task environment for %q: %v", taskID, err)
}
}
func insertContainerInventoryExecutor(
t *testing.T,
database *sqlx.DB,
taskID string,
status string,
) {
t.Helper()
if _, err := database.Exec(
"INSERT INTO executors_running (id, task_id, status, runtime) VALUES (?, ?, ?, ?)",
"executor-"+taskID, taskID, status, "docker",
); err != nil {
t.Fatalf("insert executor handle for %q: %v", taskID, err)
}
}