test(store): coverage uplift to ≥70% + missing cert_repo_test.go (T01.7, REQ-057)

---ci---
project: orca
phase: 1
milestone: v0.8
status: execute
---/ci---

internal/store/audit_repo_test.go

@@ -65,3 +65,87 @@ func TestAuditRepo_WithError(t *testing.T) {
 		t.Errorf("expected error 'exit status 1', got %q", entries[0].Error)
 	}
 }
+
+func TestAuditRepo_MetadataRoundTrip(t *testing.T) {
+	repo, cleanup := openAuditTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	want := map[string]any{"node": "node-1", "exit_code": float64(2)}
+	if err := repo.Append(ctx, &AuditEntry{
+		Actor:    "cli",
+		Action:   "node.join",
+		Resource: "node-1",
+		Result:   "success",
+		Metadata: want,
+	}); err != nil {
+		t.Fatalf("append: %v", err)
+	}
+	entries, err := repo.List(ctx, 10)
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("expected 1 entry, got %d", len(entries))
+	}
+	if entries[0].Metadata == nil {
+		t.Fatalf("metadata not round-tripped")
+	}
+	if entries[0].Metadata["node"] != "node-1" {
+		t.Errorf("metadata[node] = %v, want node-1", entries[0].Metadata["node"])
+	}
+}
+
+func TestAuditRepo_DefaultActorAndTimestamp(t *testing.T) {
+	repo, cleanup := openAuditTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	// Append with empty Actor and zero Timestamp — defaults should apply.
+	if err := repo.Append(ctx, &AuditEntry{
+		Action:   "x",
+		Resource: "y",
+		Result:   "success",
+	}); err != nil {
+		t.Fatalf("append: %v", err)
+	}
+	entries, _ := repo.List(ctx, 1)
+	if len(entries) != 1 {
+		t.Fatalf("expected 1 entry, got %d", len(entries))
+	}
+	if entries[0].Actor != "system" {
+		t.Errorf("default actor = %q, want system", entries[0].Actor)
+	}
+	if entries[0].Timestamp.IsZero() {
+		t.Errorf("default timestamp not set")
+	}
+}
+
+func TestAuditRepo_ListDefaultLimit(t *testing.T) {
+	repo, cleanup := openAuditTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	for i := 0; i < 5; i++ {
+		if err := repo.Append(ctx, &AuditEntry{
+			Action: "x", Resource: "y", Result: "success",
+		}); err != nil {
+			t.Fatalf("append[%d]: %v", i, err)
+		}
+	}
+	// limit<=0 should default to 100.
+	entries, err := repo.List(ctx, 0)
+	if err != nil {
+		t.Fatalf("List(0): %v", err)
+	}
+	if len(entries) != 5 {
+		t.Errorf("List(0): got %d, want 5", len(entries))
+	}
+	entries, err = repo.List(ctx, -1)
+	if err != nil {
+		t.Fatalf("List(-1): %v", err)
+	}
+	if len(entries) != 5 {
+		t.Errorf("List(-1): got %d, want 5", len(entries))
+	}
+}

internal/store/capacity_repo_test.go

@@ -40,6 +40,9 @@ func TestCapacityRepoUpsertGetList(t *testing.T) {
 	if got.CPUMillicores != 4000 || got.MemoryMiB != 4096 || got.DiskMiB != 4096 {
 		t.Errorf("Get: got %+v, want cpu=4000 mem=4096 disk=4096", got)
 	}
+	if got.UpdatedAt.IsZero() {
+		t.Errorf("Upsert did not fill UpdatedAt")
+	}
 
 	// Update (overwrite).
 	c2 := &NodeCapacity{NodeID: "self", CPUMillicores: 8000, MemoryMiB: 8192, DiskMiB: 8192}
@@ -72,3 +75,66 @@ func TestCapacityRepoUpsertGetList(t *testing.T) {
 		t.Error("expected ErrNotFound on Delete of missing row")
 	}
 }
+
+func TestCapacityRepo_UpsertNilAndEmptyNodeID(t *testing.T) {
+	dir := t.TempDir()
+	db, err := Open(filepath.Join(dir, "test.db"))
+	if err != nil {
+		t.Fatalf("Open: %v", err)
+	}
+	defer db.Close()
+	repo := NewCapacityRepo(db)
+	ctx := context.Background()
+
+	if err := repo.Upsert(ctx, nil); err == nil {
+		t.Error("Upsert(nil) should error")
+	}
+	if err := repo.Upsert(ctx, &NodeCapacity{NodeID: ""}); err == nil {
+		t.Error("Upsert(empty NodeID) should error")
+	}
+}
+
+func TestCapacityRepo_GetEmptyNodeID(t *testing.T) {
+	dir := t.TempDir()
+	db, err := Open(filepath.Join(dir, "test.db"))
+	if err != nil {
+		t.Fatalf("Open: %v", err)
+	}
+	defer db.Close()
+	repo := NewCapacityRepo(db)
+	ctx := context.Background()
+
+	if _, err := repo.Get(ctx, ""); err == nil {
+		t.Error("Get(empty) should error")
+	}
+}
+
+func TestCapacityRepo_DeleteMissing(t *testing.T) {
+	dir := t.TempDir()
+	db, err := Open(filepath.Join(dir, "test.db"))
+	if err != nil {
+		t.Fatalf("Open: %v", err)
+	}
+	defer db.Close()
+	repo := NewCapacityRepo(db)
+	ctx := context.Background()
+
+	if err := repo.Delete(ctx, "ghost"); err != ErrNotFound {
+		t.Errorf("Delete(ghost) = %v, want ErrNotFound", err)
+	}
+}
+
+func TestStore_OpenEmptyPath(t *testing.T) {
+	// Open with "" should fall back to certpaths.DBPath() which honors
+	// ORCA_HOME. Set a temp ORCA_HOME so we don't pollute the real home.
+	home := t.TempDir()
+	t.Setenv("ORCA_HOME", home)
+	db, err := Open("")
+	if err != nil {
+		t.Fatalf("Open(\"\"): %v", err)
+	}
+	defer db.Close()
+	if err := db.Ping(); err != nil {
+		t.Errorf("Ping: %v", err)
+	}
+}

internal/store/job_task_repo_test.go

@@ -2,6 +2,7 @@ package store
 
 import (
 	"context"
+	"database/sql"
 	"path/filepath"
 	"testing"
 	"time"
@@ -19,6 +20,368 @@ func openJobTestDB(t *testing.T) (*JobRepo, func()) {
 	return NewJobRepo(db), func() { _ = db.Close() }
 }
 
+// openFullTestDB returns the underlying *sql.DB plus repos for cross-repo
+// tests (e.g. TaskRepo needs a JobRepo parent row when foreign keys are on).
+func openFullTestDB(t *testing.T) (*sql.DB, *JobRepo, *TaskRepo, func()) {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "test.db")
+	db, err := Open(path)
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	return db, NewJobRepo(db), NewTaskRepo(db), func() { _ = db.Close() }
+}
+
+func TestJobRepo_Get(t *testing.T) {
+	repo, cleanup := openJobTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	insertJob(t, repo, ctx, "job-get", "alpha")
+
+	got, err := repo.Get(ctx, "job-get")
+	if err != nil {
+		t.Fatalf("Get: %v", err)
+	}
+	if got.ID != "job-get" || got.Name != "alpha" {
+		t.Errorf("Get: got %+v", got)
+	}
+	if got.Status != model.JobStatusPending {
+		t.Errorf("Get: status = %q, want pending", got.Status)
+	}
+	if got.Spec != "test" {
+		t.Errorf("Get: spec = %q, want test", got.Spec)
+	}
+
+	if _, err := repo.Get(ctx, "missing"); err != ErrNotFound {
+		t.Errorf("Get(missing): got %v, want ErrNotFound", err)
+	}
+}
+
+func TestJobRepo_List(t *testing.T) {
+	repo, cleanup := openJobTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	insertJob(t, repo, ctx, "j1", "first")
+	insertJob(t, repo, ctx, "j2", "second")
+	insertJob(t, repo, ctx, "j3", "third")
+
+	jobs, err := repo.List(ctx)
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(jobs) != 3 {
+		t.Fatalf("List: got %d jobs, want 3", len(jobs))
+	}
+	// ORDER BY created_at DESC — but timestamps may collide at second
+	// precision. Just verify all 3 IDs are present.
+	ids := map[string]bool{}
+	for _, j := range jobs {
+		ids[j.ID] = true
+	}
+	for _, want := range []string{"j1", "j2", "j3"} {
+		if !ids[want] {
+			t.Errorf("List: missing job %q", want)
+		}
+	}
+}
+
+func TestJobRepo_UpdateStatus(t *testing.T) {
+	repo, cleanup := openJobTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	insertJob(t, repo, ctx, "job-status", "alpha")
+
+	cases := []struct {
+		name     string
+		status   model.JobStatus
+		exitCode int
+	}{
+		{"running", model.JobStatusRunning, 0},
+		{"complete", model.JobStatusComplete, 0},
+		{"failed", model.JobStatusFailed, 1},
+		{"stopped", model.JobStatusStopped, 130},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if err := repo.UpdateStatus(ctx, "job-status", tc.status, tc.exitCode); err != nil {
+				t.Fatalf("UpdateStatus(%s): %v", tc.name, err)
+			}
+			got, err := repo.Get(ctx, "job-status")
+			if err != nil {
+				t.Fatalf("Get: %v", err)
+			}
+			if got.Status != tc.status {
+				t.Errorf("status = %q, want %q", got.Status, tc.status)
+			}
+			if got.ExitCode != tc.exitCode {
+				t.Errorf("exit_code = %d, want %d", got.ExitCode, tc.exitCode)
+			}
+			switch tc.status {
+			case model.JobStatusRunning:
+				if got.StartedAt == nil {
+					t.Errorf("started_at should be set for %s", tc.name)
+				}
+			case model.JobStatusComplete, model.JobStatusFailed, model.JobStatusStopped:
+				if got.EndedAt == nil {
+					t.Errorf("ended_at should be set for %s", tc.name)
+				}
+			}
+		})
+	}
+}
+
+func TestJobRepo_InsertDefaults(t *testing.T) {
+	repo, cleanup := openJobTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Insert with zero CreatedAt and empty Status — defaults should kick in.
+	j := &model.Job{ID: "defaults-1", Name: "d", Spec: "s"}
+	if err := repo.Insert(ctx, j); err != nil {
+		t.Fatalf("Insert: %v", err)
+	}
+	if j.CreatedAt.IsZero() {
+		t.Errorf("Insert did not fill CreatedAt")
+	}
+	if j.Status != model.JobStatusPending {
+		t.Errorf("Insert default status = %q, want pending", j.Status)
+	}
+	got, _ := repo.Get(ctx, "defaults-1")
+	if got.Status != model.JobStatusPending {
+		t.Errorf("Get: status = %q, want pending", got.Status)
+	}
+}
+
+func sampleTask(id, jobID string) *model.Task {
+	return &model.Task{
+		ID:      id,
+		JobID:   jobID,
+		Command: "/bin/echo",
+		Args:    []string{"hello", "world"},
+		Env:     []string{"FOO=bar", "BAZ=qux"},
+	}
+}
+
+func TestTaskRepo_InsertAndGet(t *testing.T) {
+	_, jobRepo, taskRepo, cleanup := openFullTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	insertJob(t, jobRepo, ctx, "job-1", "alpha")
+	tk := sampleTask("task-1", "job-1")
+	if err := taskRepo.Insert(ctx, tk); err != nil {
+		t.Fatalf("Insert: %v", err)
+	}
+	if tk.CreatedAt.IsZero() {
+		t.Errorf("Insert did not fill CreatedAt")
+	}
+	if tk.Status != model.TaskStatusPending {
+		t.Errorf("Insert default status = %q, want pending", tk.Status)
+	}
+
+	got, err := taskRepo.Get(ctx, "task-1")
+	if err != nil {
+		t.Fatalf("Get: %v", err)
+	}
+	if got.Command != "/bin/echo" {
+		t.Errorf("command = %q", got.Command)
+	}
+	if len(got.Args) != 2 || got.Args[0] != "hello" {
+		t.Errorf("args = %v", got.Args)
+	}
+	if len(got.Env) != 2 || got.Env[0] != "FOO=bar" {
+		t.Errorf("env = %v", got.Env)
+	}
+	if got.Status != model.TaskStatusPending {
+		t.Errorf("status = %q, want pending", got.Status)
+	}
+
+	if _, err := taskRepo.Get(ctx, "missing"); err != ErrNotFound {
+		t.Errorf("Get(missing) = %v, want ErrNotFound", err)
+	}
+}
+
+func TestTaskRepo_ListByJob(t *testing.T) {
+	_, jobRepo, taskRepo, cleanup := openFullTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	insertJob(t, jobRepo, ctx, "job-lbj", "alpha")
+	for _, id := range []string{"t1", "t2", "t3"} {
+		if err := taskRepo.Insert(ctx, sampleTask(id, "job-lbj")); err != nil {
+			t.Fatalf("Insert %s: %v", id, err)
+		}
+	}
+	// Insert a task for a different job to ensure filtering works.
+	insertJob(t, jobRepo, ctx, "job-other", "beta")
+	if err := taskRepo.Insert(ctx, sampleTask("t-other", "job-other")); err != nil {
+		t.Fatalf("Insert t-other: %v", err)
+	}
+
+	tasks, err := taskRepo.ListByJob(ctx, "job-lbj")
+	if err != nil {
+		t.Fatalf("ListByJob: %v", err)
+	}
+	if len(tasks) != 3 {
+		t.Fatalf("ListByJob: got %d tasks, want 3", len(tasks))
+	}
+	for _, tk := range tasks {
+		if tk.JobID != "job-lbj" {
+			t.Errorf("ListByJob returned task with job_id=%q", tk.JobID)
+		}
+	}
+}
+
+func TestTaskRepo_UpdateRunning(t *testing.T) {
+	_, jobRepo, taskRepo, cleanup := openFullTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	insertJob(t, jobRepo, ctx, "job-run", "alpha")
+	if err := taskRepo.Insert(ctx, sampleTask("task-run", "job-run")); err != nil {
+		t.Fatalf("Insert: %v", err)
+	}
+	if err := taskRepo.UpdateRunning(ctx, "task-run", 4242); err != nil {
+		t.Fatalf("UpdateRunning: %v", err)
+	}
+	got, _ := taskRepo.Get(ctx, "task-run")
+	if got.PID != 4242 {
+		t.Errorf("pid = %d, want 4242", got.PID)
+	}
+	if got.Status != model.TaskStatusRunning {
+		t.Errorf("status = %q, want running", got.Status)
+	}
+	if got.StartedAt == nil {
+		t.Errorf("started_at should be set after UpdateRunning")
+	}
+}
+
+func TestTaskRepo_UpdateDone(t *testing.T) {
+	_, jobRepo, taskRepo, cleanup := openFullTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	insertJob(t, jobRepo, ctx, "job-done", "alpha")
+	if err := taskRepo.Insert(ctx, sampleTask("task-done", "job-done")); err != nil {
+		t.Fatalf("Insert: %v", err)
+	}
+
+	cases := []struct {
+		name     string
+		exitCode int
+		want     model.TaskStatus
+	}{
+		{"complete", 0, model.TaskStatusComplete},
+		{"failed", 1, model.TaskStatusFailed},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			id := "task-done-" + tc.name
+			if err := taskRepo.Insert(ctx, sampleTask(id, "job-done")); err != nil {
+				t.Fatalf("Insert: %v", err)
+			}
+			if err := taskRepo.UpdateDone(ctx, id, tc.exitCode, "stdout-data", "stderr-data"); err != nil {
+				t.Fatalf("UpdateDone: %v", err)
+			}
+			got, _ := taskRepo.Get(ctx, id)
+			if got.Status != tc.want {
+				t.Errorf("status = %q, want %q", got.Status, tc.want)
+			}
+			if got.ExitCode != tc.exitCode {
+				t.Errorf("exit_code = %d, want %d", got.ExitCode, tc.exitCode)
+			}
+			if got.Stdout != "stdout-data" {
+				t.Errorf("stdout = %q", got.Stdout)
+			}
+			if got.Stderr != "stderr-data" {
+				t.Errorf("stderr = %q", got.Stderr)
+			}
+			if got.EndedAt == nil {
+				t.Errorf("ended_at should be set after UpdateDone")
+			}
+		})
+	}
+}
+
+func TestTaskRepo_UpdateKilled(t *testing.T) {
+	_, jobRepo, taskRepo, cleanup := openFullTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	insertJob(t, jobRepo, ctx, "job-kill", "alpha")
+	if err := taskRepo.Insert(ctx, sampleTask("task-kill", "job-kill")); err != nil {
+		t.Fatalf("Insert: %v", err)
+	}
+	if err := taskRepo.UpdateKilled(ctx, "task-kill"); err != nil {
+		t.Fatalf("UpdateKilled: %v", err)
+	}
+	got, _ := taskRepo.Get(ctx, "task-kill")
+	if got.Status != model.TaskStatusKilled {
+		t.Errorf("status = %q, want killed", got.Status)
+	}
+	if got.EndedAt == nil {
+		t.Errorf("ended_at should be set after UpdateKilled")
+	}
+}
+
+func TestTaskRepo_ListRecent(t *testing.T) {
+	_, jobRepo, taskRepo, cleanup := openFullTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	insertJob(t, jobRepo, ctx, "job-recent", "alpha")
+	for i := 0; i < 5; i++ {
+		id := "task-recent-" + string(rune('a'+i))
+		if err := taskRepo.Insert(ctx, sampleTask(id, "job-recent")); err != nil {
+			t.Fatalf("Insert %s: %v", id, err)
+		}
+	}
+
+	// limit=3
+	tasks, err := taskRepo.ListRecent(ctx, 3)
+	if err != nil {
+		t.Fatalf("ListRecent(3): %v", err)
+	}
+	if len(tasks) != 3 {
+		t.Errorf("ListRecent(3): got %d, want 3", len(tasks))
+	}
+
+	// limit<=0 → defaults to 100
+	all, err := taskRepo.ListRecent(ctx, 0)
+	if err != nil {
+		t.Fatalf("ListRecent(0): %v", err)
+	}
+	if len(all) != 5 {
+		t.Errorf("ListRecent(0): got %d, want 5 (default limit 100)", len(all))
+	}
+
+	// limit negative
+	neg, err := taskRepo.ListRecent(ctx, -1)
+	if err != nil {
+		t.Fatalf("ListRecent(-1): %v", err)
+	}
+	if len(neg) != 5 {
+		t.Errorf("ListRecent(-1): got %d, want 5", len(neg))
+	}
+}
+
+func TestTaskRepo_ListByJob_Empty(t *testing.T) {
+	_, _, taskRepo, cleanup := openFullTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	tasks, err := taskRepo.ListByJob(ctx, "nope")
+	if err != nil {
+		t.Fatalf("ListByJob: %v", err)
+	}
+	if len(tasks) != 0 {
+		t.Errorf("ListByJob(empty): got %d, want 0", len(tasks))
+	}
+}
+
 func insertJob(t *testing.T, repo *JobRepo, ctx context.Context, id, name string) {
 	t.Helper()
 	if err := repo.Insert(ctx, &model.Job{

internal/store/node_repo_test.go

@@ -101,6 +101,133 @@ func TestNodeRepo_Delete(t *testing.T) {
 	}
 }
 
+func TestNodeRepo_DeleteMissing(t *testing.T) {
+	repo, cleanup := openTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	if err := repo.Delete(ctx, "ghost"); err != ErrNotFound {
+		t.Errorf("Delete(ghost) = %v, want ErrNotFound", err)
+	}
+}
+
+func TestNodeRepo_UpdateStateMissing(t *testing.T) {
+	repo, cleanup := openTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	if err := repo.UpdateState(ctx, "ghost", model.NodeStateLeft); err != ErrNotFound {
+		t.Errorf("UpdateState(ghost) = %v, want ErrNotFound", err)
+	}
+}
+
+func TestNodeRepo_UpdateLastSeenAndOSMissing(t *testing.T) {
+	repo, cleanup := openTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	if err := repo.UpdateLastSeenAndOS(ctx, "ghost", "ubuntu"); err != ErrNotFound {
+		t.Errorf("UpdateLastSeenAndOS(ghost) = %v, want ErrNotFound", err)
+	}
+}
+
+func TestNodeRepo_GetMissing(t *testing.T) {
+	repo, cleanup := openTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	if _, err := repo.Get(ctx, "ghost"); err != ErrNotFound {
+		t.Errorf("Get(ghost) = %v, want ErrNotFound", err)
+	}
+}
+
+func TestNodeRepo_InsertDefaults(t *testing.T) {
+	repo, cleanup := openTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	// Insert with zero JoinedAt/LastSeen and empty State — defaults apply.
+	n := &model.Node{ID: "defaults-1", Name: "d", Address: "addr"}
+	if err := repo.Insert(ctx, n); err != nil {
+		t.Fatalf("Insert: %v", err)
+	}
+	if n.JoinedAt.IsZero() {
+		t.Errorf("Insert did not fill JoinedAt")
+	}
+	if n.LastSeen.IsZero() {
+		t.Errorf("Insert did not fill LastSeen")
+	}
+	if n.State != model.NodeStateReady {
+		t.Errorf("Insert default state = %q, want ready", n.State)
+	}
+}
+
+func TestNodeRepo_MetadataRoundTrip(t *testing.T) {
+	repo, cleanup := openTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	n := &model.Node{
+		ID:       "meta-1",
+		Name:     "meta",
+		Address:  "addr",
+		JoinedAt: time.Now().UTC(),
+		LastSeen: time.Now().UTC(),
+		Metadata: map[string]string{"arch": "amd64", "kernel": "6.1"},
+	}
+	if err := repo.Insert(ctx, n); err != nil {
+		t.Fatalf("Insert: %v", err)
+	}
+	got, err := repo.Get(ctx, "meta-1")
+	if err != nil {
+		t.Fatalf("Get: %v", err)
+	}
+	if got.Metadata["arch"] != "amd64" {
+		t.Errorf("metadata[arch] = %q, want amd64", got.Metadata["arch"])
+	}
+	if got.Metadata["kernel"] != "6.1" {
+		t.Errorf("metadata[kernel] = %q, want 6.1", got.Metadata["kernel"])
+	}
+}
+
+func TestNodeRepo_ListEmpty(t *testing.T) {
+	repo, cleanup := openTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	nodes, err := repo.List(ctx)
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(nodes) != 0 {
+		t.Errorf("List(empty): got %d, want 0", len(nodes))
+	}
+}
+
+func TestNodeRepo_GetByNameMultiplePicksOldest(t *testing.T) {
+	repo, cleanup := openTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	older := time.Now().UTC().Add(-1 * time.Hour)
+	newer := time.Now().UTC()
+	_ = repo.Insert(ctx, &model.Node{
+		ID: "n-old", Name: "dup", Address: "a",
+		JoinedAt: older, LastSeen: older,
+	})
+	_ = repo.Insert(ctx, &model.Node{
+		ID: "n-new", Name: "dup", Address: "a",
+		JoinedAt: newer, LastSeen: newer,
+	})
+	got, err := repo.GetByName(ctx, "dup")
+	if err != nil {
+		t.Fatalf("GetByName: %v", err)
+	}
+	if got.ID != "n-old" {
+		t.Errorf("GetByName = %q, want oldest n-old (ORDER BY joined_at ASC)", got.ID)
+	}
+}
+
 func TestNodeRepo_KindOS_RoundTrip(t *testing.T) {
 	repo, cleanup := openTestDB(t)
 	defer cleanup()