Function TestManagerRecoverRunOnBoot

internal/task/manager_test.go:8423–8781

(t *testing.T)

}

func TestManagerRecoverRunOnBoot(t *testing.T) {
	t.Parallel()

	daemonActor, err := DeriveDaemonActorContext("boot-recovery", "daemon.boot")
	if err != nil {
		t.Fatalf("DeriveDaemonActorContext() error = %v", err)
	}

	t.Run("Should claimed run requeues and records recovery event", func(t *testing.T) {
		t.Parallel()

		store := newInMemoryManagerStore()
		manager := newTaskManagerForTest(t, store)
		actor := validActorContext()

		taskRecord, err := manager.CreateTask(context.Background(), CreateTask{
			Scope: ScopeGlobal,
			Title: "Claimed recovery",
		}, actor)
		if err != nil {
			t.Fatalf("CreateTask() error = %v", err)
		}
		run, err := manager.EnqueueRun(
			context.Background(),
			EnqueueRun{TaskID: taskRecord.ID},
			actor,
		)
		if err != nil {
			t.Fatalf("EnqueueRun() error = %v", err)
		}
		run, err = manager.ClaimRun(context.Background(), run.ID, ClaimRun{}, actor)
		if err != nil {
			t.Fatalf("ClaimRun() error = %v", err)
		}

		recovered, err := manager.RecoverRunOnBoot(context.Background(), run.ID, RunBootRecovery{
			Action:       RunBootRecoveryRequeue,
			Reason:       "orphaned_on_boot",
			SessionState: "missing",
		}, daemonActor)
		if err != nil {
			t.Fatalf("RecoverRunOnBoot(requeue) error = %v", err)
		}
		if got, want := recovered.Status, TaskRunStatusQueued; got != want {
			t.Fatalf("recovered.Status = %q, want %q", got, want)
		}
		if recovered.ClaimedBy != nil {
			t.Fatalf("recovered.ClaimedBy = %#v, want nil", recovered.ClaimedBy)
		}
		if !store.runs[run.ID].ClaimedAt.IsZero() {
			t.Fatalf(
				"store.runs[%q].ClaimedAt = %v, want zero",
				run.ID,
				store.runs[run.ID].ClaimedAt,
			)
		}

		events, err := store.ListTaskEvents(context.Background(), EventQuery{TaskID: taskRecord.ID})