Files
kandev/apps/backend/internal/azuredevops/store_test.go
T
2026-08-02 17:08:22 +01:00

410 lines
13 KiB
Go

package azuredevops
import (
"context"
"database/sql"
"fmt"
"sync"
"testing"
"time"
"github.com/jmoiron/sqlx"
_ "github.com/mattn/go-sqlite3"
)
func newTestDB(t *testing.T) *sqlx.DB {
t.Helper()
raw, err := sql.Open("sqlite3", ":memory:")
if err != nil {
t.Fatalf("open sqlite: %v", err)
}
raw.SetMaxOpenConns(1)
raw.SetMaxIdleConns(1)
db := sqlx.NewDb(raw, "sqlite3")
t.Cleanup(func() { _ = db.Close() })
return db
}
func TestStoreConfigRoundTripAndHealth(t *testing.T) {
db := newTestDB(t)
store, err := NewStore(db, db)
if err != nil {
t.Fatalf("new store: %v", err)
}
ctx := context.Background()
cfg := &Config{
WorkspaceID: "ws-a",
OrganizationURL: "https://dev.azure.com/acme",
DefaultProjectID: "project-guid",
DefaultProjectName: "Platform",
AuthMethod: AuthMethodPAT,
}
if err := store.UpsertConfig(ctx, cfg); err != nil {
t.Fatalf("upsert: %v", err)
}
checkedAt := time.Now().UTC().Truncate(time.Millisecond)
if err := store.UpdateAuthHealth(ctx, "ws-a", true, "", checkedAt); err != nil {
t.Fatalf("update health: %v", err)
}
got, err := store.GetConfig(ctx, "ws-a")
if err != nil {
t.Fatalf("get: %v", err)
}
if got == nil || got.OrganizationURL != cfg.OrganizationURL || got.DefaultProjectID != cfg.DefaultProjectID {
t.Fatalf("round trip mismatch: got %+v want %+v", got, cfg)
}
if !got.LastOK || got.LastCheckedAt == nil || got.LastError != "" {
t.Fatalf("health not persisted: %+v", got)
}
if got.CreatedAt.IsZero() || got.UpdatedAt.IsZero() {
t.Fatalf("timestamps not populated: %+v", got)
}
ids, err := store.ListConfigWorkspaceIDs(ctx)
if err != nil {
t.Fatalf("list workspace ids: %v", err)
}
if len(ids) != 1 || ids[0] != "ws-a" {
t.Fatalf("workspace ids = %v", ids)
}
}
func TestStoreConfigReplayAndDelete(t *testing.T) {
db := newTestDB(t)
first, err := NewStore(db, db)
if err != nil {
t.Fatalf("first store: %v", err)
}
if err := first.UpsertConfig(context.Background(), &Config{
WorkspaceID: "ws-a", OrganizationURL: "https://dev.azure.com/acme", AuthMethod: AuthMethodPAT,
}); err != nil {
t.Fatalf("upsert: %v", err)
}
second, err := NewStore(db, db)
if err != nil {
t.Fatalf("replayed store: %v", err)
}
if err := second.DeleteConfig(context.Background(), "ws-a"); err != nil {
t.Fatalf("delete: %v", err)
}
got, err := second.GetConfig(context.Background(), "ws-a")
if err != nil || got != nil {
t.Fatalf("after delete got=%+v err=%v", got, err)
}
}
func TestWorkspaceSettingsConditionalWriteRejectsStaleVersion(t *testing.T) {
db := newTestDB(t)
store, err := NewStore(db, db)
if err != nil {
t.Fatalf("new store: %v", err)
}
ctx := context.Background()
if err := store.UpsertConfig(ctx, &Config{
WorkspaceID: "ws-a", OrganizationURL: "https://dev.azure.com/acme", AuthMethod: AuthMethodPAT,
}); err != nil {
t.Fatalf("upsert config: %v", err)
}
snapshot, err := store.GetWorkspaceSettingsSnapshot(ctx, "ws-a")
if err != nil {
t.Fatalf("get workspace settings snapshot: %v", err)
}
if snapshot.JSON != "{}" || snapshot.Version != 0 {
t.Fatalf("initial snapshot = %+v, want empty settings at version 0", snapshot)
}
updated, err := store.PutWorkspaceSettingsJSONIfVersion(ctx, "ws-a", `{"workItemActions":[]}`, snapshot.Version)
if err != nil || !updated {
t.Fatalf("conditional write = %t, %v, want success", updated, err)
}
updated, err = store.PutWorkspaceSettingsJSONIfVersion(ctx, "ws-a", `{"pullRequestActions":[]}`, snapshot.Version)
if err != nil {
t.Fatalf("stale conditional write: %v", err)
}
if updated {
t.Fatal("stale conditional write unexpectedly succeeded")
}
current, err := store.GetWorkspaceSettingsSnapshot(ctx, "ws-a")
if err != nil {
t.Fatalf("get current workspace settings snapshot: %v", err)
}
if current.JSON != `{"workItemActions":[]}` || current.Version != 1 {
t.Fatalf("current snapshot = %+v, want successful write at version 1", current)
}
}
func TestWorkspaceSettingsVersionMigratesExistingConfigTable(t *testing.T) {
db := newTestDB(t)
_, err := db.Exec(`
CREATE TABLE azure_devops_configs (
workspace_id TEXT PRIMARY KEY,
organization_url TEXT NOT NULL,
default_project_id TEXT NOT NULL DEFAULT '',
default_project_name TEXT NOT NULL DEFAULT '',
auth_method TEXT NOT NULL DEFAULT 'pat',
last_checked_at DATETIME,
last_ok BOOLEAN NOT NULL DEFAULT 0,
last_error TEXT NOT NULL DEFAULT '',
saved_views TEXT NOT NULL DEFAULT '[]',
workspace_settings TEXT NOT NULL DEFAULT '{}',
created_at DATETIME NOT NULL,
updated_at DATETIME NOT NULL
)`)
if err != nil {
t.Fatalf("create previous config schema: %v", err)
}
store, err := NewStore(db, db)
if err != nil {
t.Fatalf("migrate config schema: %v", err)
}
ctx := context.Background()
if err := store.UpsertConfig(ctx, &Config{
WorkspaceID: "ws-a", OrganizationURL: "https://dev.azure.com/acme", AuthMethod: AuthMethodPAT,
}); err != nil {
t.Fatalf("upsert config: %v", err)
}
snapshot, err := store.GetWorkspaceSettingsSnapshot(ctx, "ws-a")
if err != nil {
t.Fatalf("get migrated workspace settings snapshot: %v", err)
}
if snapshot.Version != 0 {
t.Fatalf("migrated settings version = %d, want 0", snapshot.Version)
}
if _, err := NewStore(db, db); err != nil {
t.Fatalf("replay migrated config schema: %v", err)
}
}
func TestStoreTaskPRSchemaAndReplay(t *testing.T) {
db := newTestDB(t)
if _, err := NewStore(db, db); err != nil {
t.Fatalf("first store: %v", err)
}
var tableName string
if err := db.Get(&tableName, `SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'azure_devops_task_prs'`); err != nil {
t.Fatalf("task PR table missing: %v", err)
}
if tableName != "azure_devops_task_prs" {
t.Fatalf("task PR table = %q", tableName)
}
if _, err := NewStore(db, db); err != nil {
t.Fatalf("replayed store: %v", err)
}
}
type taskPRStoreContract interface {
UpsertTaskPR(context.Context, *TaskPR) error
ListTaskPRsByTask(context.Context, string) ([]*TaskPR, error)
ListTaskPRsByWorkspace(context.Context, string) (map[string][]*TaskPR, error)
DeleteTaskPRsByTask(context.Context, string) error
}
type taskWorkItemStoreContract interface {
UpsertTaskWorkItem(context.Context, *TaskWorkItem) error
ListTaskWorkItemsByWorkspace(context.Context, string) (map[string][]*TaskWorkItem, error)
DeleteTaskWorkItemsByTask(context.Context, string) error
DeleteTaskWorkItemsByWorkspace(context.Context, string) error
}
func TestStoreDeleteTaskWorkItemsIsScoped(t *testing.T) {
store, err := NewStore(newTestDB(t), nil)
if err != nil {
t.Fatalf("new store: %v", err)
}
contract, ok := any(store).(taskWorkItemStoreContract)
if !ok {
t.Fatal("Store does not implement the task work item persistence contract")
}
ctx := context.Background()
for _, row := range []*TaskWorkItem{
{TaskID: "task-a", WorkspaceID: "workspace-a", ProjectID: "project-a", WorkItemID: 1},
{TaskID: "task-b", WorkspaceID: "workspace-a", ProjectID: "project-a", WorkItemID: 2},
{TaskID: "task-c", WorkspaceID: "workspace-b", ProjectID: "project-b", WorkItemID: 3},
} {
if err := contract.UpsertTaskWorkItem(ctx, row); err != nil {
t.Fatalf("upsert task work item: %v", err)
}
}
if err := contract.DeleteTaskWorkItemsByTask(ctx, "task-a"); err != nil {
t.Fatalf("delete task work items by task: %v", err)
}
byWorkspace, err := contract.ListTaskWorkItemsByWorkspace(ctx, "workspace-a")
if err != nil || len(byWorkspace["task-a"]) != 0 || len(byWorkspace["task-b"]) != 1 {
t.Fatalf("task-scoped deletion result = %+v, err = %v", byWorkspace, err)
}
if err := contract.DeleteTaskWorkItemsByWorkspace(ctx, "workspace-a"); err != nil {
t.Fatalf("delete task work items by workspace: %v", err)
}
byWorkspace, err = contract.ListTaskWorkItemsByWorkspace(ctx, "workspace-b")
if err != nil || len(byWorkspace["task-c"]) != 1 {
t.Fatalf("workspace-scoped deletion result = %+v, err = %v", byWorkspace, err)
}
}
func TestStoreDeleteTaskPRsByTaskIsScoped(t *testing.T) {
store, err := NewStore(newTestDB(t), nil)
if err != nil {
t.Fatalf("new store: %v", err)
}
ctx := context.Background()
for _, row := range []*TaskPR{
testTaskPR("task-a", "repo-a", 1),
testTaskPR("task-b", "repo-b", 2),
} {
if err := store.UpsertTaskPR(ctx, row); err != nil {
t.Fatalf("upsert task PR: %v", err)
}
}
if err := store.DeleteTaskPRsByTask(ctx, "task-a"); err != nil {
t.Fatalf("delete task PRs: %v", err)
}
deleted, err := store.ListTaskPRsByTask(ctx, "task-a")
if err != nil || len(deleted) != 0 {
t.Fatalf("deleted task rows = %+v, err = %v", deleted, err)
}
remaining, err := store.ListTaskPRsByTask(ctx, "task-b")
if err != nil || len(remaining) != 1 {
t.Fatalf("remaining task rows = %+v, err = %v", remaining, err)
}
}
func TestStoreTaskPRUpsertAndRestartPersistence(t *testing.T) {
db := newTestDB(t)
store, err := NewStore(db, db)
if err != nil {
t.Fatalf("new store: %v", err)
}
contract, ok := any(store).(taskPRStoreContract)
if !ok {
t.Fatal("Store does not implement the task PR persistence contract")
}
ctx := context.Background()
first := testTaskPR("task-a", "repo-a", 42)
if err := contract.UpsertTaskPR(ctx, first); err != nil {
t.Fatalf("first upsert: %v", err)
}
firstID, firstCreatedAt := first.ID, first.CreatedAt
first.Title = "Updated title"
first.ReviewState = "approved"
if err := contract.UpsertTaskPR(ctx, first); err != nil {
t.Fatalf("second upsert: %v", err)
}
replayed, err := NewStore(db, db)
if err != nil {
t.Fatalf("replayed store: %v", err)
}
replayedContract, ok := any(replayed).(taskPRStoreContract)
if !ok {
t.Fatal("replayed Store does not implement the task PR persistence contract")
}
rows, err := replayedContract.ListTaskPRsByTask(ctx, "task-a")
if err != nil {
t.Fatalf("list by task: %v", err)
}
if len(rows) != 1 || rows[0].ID != firstID || !rows[0].CreatedAt.Equal(firstCreatedAt) {
t.Fatalf("upsert changed stable identity: %+v", rows)
}
if rows[0].Title != "Updated title" || rows[0].ReviewState != "approved" {
t.Fatalf("mutable fields were not refreshed: %+v", rows[0])
}
}
func TestStoreTaskPRConcurrentUpsertPreservesStableIdentity(t *testing.T) {
store, err := NewStore(newTestDB(t), nil)
if err != nil {
t.Fatalf("new store: %v", err)
}
const writers = 12
ids := make(chan string, writers)
errs := make(chan error, writers)
var wait sync.WaitGroup
for index := 0; index < writers; index++ {
wait.Add(1)
go func(index int) {
defer wait.Done()
row := testTaskPR("task-a", "repo-a", 42)
row.Title = fmt.Sprintf("Title %d", index)
if err := store.UpsertTaskPR(context.Background(), row); err != nil {
errs <- err
return
}
ids <- row.ID
}(index)
}
wait.Wait()
close(errs)
close(ids)
for err := range errs {
t.Fatalf("concurrent upsert: %v", err)
}
stableID := ""
for id := range ids {
if stableID == "" {
stableID = id
}
if id != stableID {
t.Fatalf("concurrent upsert IDs differ: %q and %q", stableID, id)
}
}
rows, err := store.ListTaskPRsByTask(context.Background(), "task-a")
if err != nil || len(rows) != 1 || rows[0].ID != stableID {
t.Fatalf("rows after concurrent upsert = %+v, err = %v", rows, err)
}
}
func TestStoreTaskPRListsByTaskAndWorkspace(t *testing.T) {
db := newTestDB(t)
if _, err := db.Exec(`CREATE TABLE tasks (id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL)`); err != nil {
t.Fatalf("create tasks table: %v", err)
}
if _, err := db.Exec(`INSERT INTO tasks (id, workspace_id) VALUES ('task-a', 'ws-a'), ('task-b', 'ws-a'), ('task-c', 'ws-b')`); err != nil {
t.Fatalf("seed tasks: %v", err)
}
store, err := NewStore(db, db)
if err != nil {
t.Fatalf("new store: %v", err)
}
contract, ok := any(store).(taskPRStoreContract)
if !ok {
t.Fatal("Store does not implement the task PR persistence contract")
}
ctx := context.Background()
for _, row := range []*TaskPR{
testTaskPR("task-a", "repo-a", 1),
testTaskPR("task-a", "repo-b", 2),
testTaskPR("task-b", "repo-a", 3),
testTaskPR("task-c", "repo-c", 4),
} {
if err := contract.UpsertTaskPR(ctx, row); err != nil {
t.Fatalf("upsert task PR: %v", err)
}
}
byTask, err := contract.ListTaskPRsByTask(ctx, "task-a")
if err != nil || len(byTask) != 2 {
t.Fatalf("list by task: rows=%+v err=%v", byTask, err)
}
byWorkspace, err := contract.ListTaskPRsByWorkspace(ctx, "ws-a")
if err != nil {
t.Fatalf("list by workspace: %v", err)
}
if len(byWorkspace) != 2 || len(byWorkspace["task-a"]) != 2 || len(byWorkspace["task-b"]) != 1 {
t.Fatalf("workspace grouping = %+v", byWorkspace)
}
if _, leaked := byWorkspace["task-c"]; leaked {
t.Fatalf("workspace result leaked task-c: %+v", byWorkspace)
}
}
func testTaskPR(taskID, repositoryID string, pullRequestID int) *TaskPR {
return &TaskPR{
TaskID: taskID, RepositoryID: repositoryID,
OrganizationURL: "https://dev.azure.com/acme", ProjectID: "project-1",
AzureRepositoryID: repositoryID + "-azure", PullRequestID: pullRequestID,
PullRequestURL: "https://dev.azure.com/acme/project/_git/repo/pullrequest/42",
Title: "Initial title", SourceBranch: "feature", TargetBranch: "main",
AuthorID: "author-1", AuthorName: "Ada", Status: "active",
}
}