feat(agent): add outcome-aware unit dependencies Extend the unit manager for declarative script ordering without changing existing status dependencies or `coder exp sync` behavior. - Add a separate conditional dependency graph with `success` and `completion` requirements, outcome tracking, and runnable, skipped, or waiting decisions. - Failed, timed-out, or skipped prerequisites skip `success` dependents but satisfy `completion`. Canceled or unregistered prerequisites keep dependents waiting. - Add context-cancelable waiting with no built-in timeout and sorted unmet prerequisites for logging. Callers remain responsible for recording skips. - Enforce immutable final outcomes, reject cycles and conflicting edge requirements, and accept identical duplicate edges. - Add race-tested coverage for outcome semantics, validation, graph isolation, cancellation, and concurrent waiters. No callers yet; script-runner integration follows in PLAT-549. Refs PLAT-546.
660 lines
23 KiB
Go
660 lines
23 KiB
Go
package unit_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/coder/coder/v2/agent/unit"
|
|
"github.com/coder/coder/v2/testutil"
|
|
)
|
|
|
|
func TestManager_ConditionalDependencyValidation(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("InvalidArguments", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
require.NoError(t, manager.Register(unitA))
|
|
|
|
err := manager.AddConditionalDependency("", unitB, unit.RequirementSuccess)
|
|
require.ErrorIs(t, err, unit.ErrUnitIDRequired)
|
|
err = manager.AddConditionalDependency(unitA, "", unit.RequirementSuccess)
|
|
require.ErrorIs(t, err, unit.ErrUnitIDRequired)
|
|
err = manager.AddConditionalDependency(unitB, unitA, unit.RequirementSuccess)
|
|
require.ErrorIs(t, err, unit.ErrUnitNotFound)
|
|
err = manager.AddConditionalDependency(unitA, unitB, unit.RequirementSuccess)
|
|
require.ErrorIs(t, err, unit.ErrUnitNotFound)
|
|
|
|
require.NoError(t, manager.Register(unitB))
|
|
err = manager.AddConditionalDependency(unitA, unitB, "unknown")
|
|
require.ErrorIs(t, err, unit.ErrInvalidRequirement)
|
|
err = manager.AddConditionalDependency(unitA, unitB, "")
|
|
require.ErrorIs(t, err, unit.ErrInvalidRequirement)
|
|
})
|
|
|
|
t.Run("Cycle", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
require.NoError(t, manager.Register(unitA))
|
|
require.NoError(t, manager.Register(unitB))
|
|
require.NoError(t, manager.AddConditionalDependency(unitA, unitB, unit.RequirementSuccess))
|
|
|
|
err := manager.AddConditionalDependency(unitB, unitA, unit.RequirementCompletion)
|
|
require.ErrorIs(t, err, unit.ErrCycleDetected)
|
|
require.ErrorIs(t, err, unit.ErrFailedToAddDependency)
|
|
})
|
|
|
|
t.Run("SameRequirementTwiceIsOneEdge", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := conditionalManager(t, unit.RequirementSuccess)
|
|
require.NoError(t, manager.AddConditionalDependency(unitA, unitB, unit.RequirementSuccess))
|
|
|
|
evaluation, err := manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionWaiting, evaluation.Decision)
|
|
require.Len(t, evaluation.UnmetDependencies, 1)
|
|
})
|
|
|
|
t.Run("ConflictingRequirementIsRejected", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := conditionalManager(t, unit.RequirementSuccess)
|
|
err := manager.AddConditionalDependency(unitA, unitB, unit.RequirementCompletion)
|
|
require.ErrorIs(t, err, unit.ErrConflictingRequirement)
|
|
|
|
// The first edge stands: a failed prerequisite still skips the dependent.
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeFailed))
|
|
evaluation, err := manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionSkip, evaluation.Decision)
|
|
require.Equal(t, unit.RequirementSuccess, evaluation.UnmetDependencies[0].Requirement)
|
|
})
|
|
}
|
|
|
|
func TestManager_UpdateOutcome(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("Transitions", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
require.NoError(t, manager.Register(unitA))
|
|
|
|
snapshot, err := manager.Unit(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.OutcomePending, snapshot.Outcome())
|
|
|
|
require.NoError(t, manager.UpdateOutcome(unitA, unit.OutcomeRunning))
|
|
snapshot, err = manager.Unit(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.OutcomeRunning, snapshot.Outcome())
|
|
|
|
require.NoError(t, manager.UpdateOutcome(unitA, unit.OutcomeSucceeded))
|
|
snapshot, err = manager.Unit(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.OutcomeSucceeded, snapshot.Outcome())
|
|
})
|
|
|
|
t.Run("InvalidArguments", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
require.NoError(t, manager.Register(unitA))
|
|
require.NoError(t, manager.UpdateOutcome(unitA, unit.OutcomeRunning))
|
|
|
|
err := manager.UpdateOutcome(unitA, unit.OutcomeRunning)
|
|
require.ErrorIs(t, err, unit.ErrSameOutcomeAlreadySet)
|
|
err = manager.UpdateOutcome(unitA, "unknown")
|
|
require.ErrorIs(t, err, unit.ErrInvalidOutcome)
|
|
err = manager.UpdateOutcome(unitA, unit.OutcomeNotRegistered)
|
|
require.ErrorIs(t, err, unit.ErrInvalidOutcome)
|
|
err = manager.UpdateOutcome(unitB, unit.OutcomeRunning)
|
|
require.ErrorIs(t, err, unit.ErrUnitNotFound)
|
|
err = manager.UpdateOutcome("", unit.OutcomeRunning)
|
|
require.ErrorIs(t, err, unit.ErrUnitIDRequired)
|
|
})
|
|
|
|
t.Run("TerminalOutcomeIsFinal", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, terminal := range []unit.Outcome{
|
|
unit.OutcomeSucceeded,
|
|
unit.OutcomeFailed,
|
|
unit.OutcomeTimedOut,
|
|
unit.OutcomeSkipped,
|
|
unit.OutcomeCanceled,
|
|
} {
|
|
manager := unit.NewManager()
|
|
require.NoError(t, manager.Register(unitA))
|
|
require.NoError(t, manager.UpdateOutcome(unitA, terminal))
|
|
|
|
for _, next := range []unit.Outcome{
|
|
unit.OutcomeRunning,
|
|
unit.OutcomeSucceeded,
|
|
unit.OutcomeFailed,
|
|
unit.OutcomeCanceled,
|
|
} {
|
|
if next == terminal {
|
|
continue
|
|
}
|
|
err := manager.UpdateOutcome(unitA, next)
|
|
require.ErrorIs(t, err, unit.ErrOutcomeAlreadyTerminal, "%s -> %s", terminal, next)
|
|
}
|
|
|
|
snapshot, err := manager.Unit(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, terminal, snapshot.Outcome())
|
|
}
|
|
})
|
|
|
|
t.Run("CanceledWhilePendingOrRunning", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
require.NoError(t, manager.Register(unitA))
|
|
require.NoError(t, manager.Register(unitB))
|
|
|
|
require.NoError(t, manager.UpdateOutcome(unitA, unit.OutcomeCanceled))
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeRunning))
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeCanceled))
|
|
|
|
for _, id := range []unit.ID{unitA, unitB} {
|
|
snapshot, err := manager.Unit(id)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.OutcomeCanceled, snapshot.Outcome())
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestManager_ConditionalDependenciesPreserveStatusDependencies(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
require.NoError(t, manager.Register(unitA))
|
|
require.NoError(t, manager.Register(unitB))
|
|
require.NoError(t, manager.AddConditionalDependency(unitA, unitB, unit.RequirementSuccess))
|
|
|
|
ready, err := manager.IsReady(unitA)
|
|
require.NoError(t, err)
|
|
require.True(t, ready)
|
|
evaluation, err := manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionWaiting, evaluation.Decision)
|
|
|
|
require.NoError(t, manager.AddDependency(unitA, unitB, unit.StatusStarted))
|
|
ready, err = manager.IsReady(unitA)
|
|
require.NoError(t, err)
|
|
require.False(t, ready)
|
|
require.NoError(t, manager.UpdateStatus(unitB, unit.StatusStarted))
|
|
ready, err = manager.IsReady(unitA)
|
|
require.NoError(t, err)
|
|
require.True(t, ready)
|
|
|
|
evaluation, err = manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionWaiting, evaluation.Decision)
|
|
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeSucceeded))
|
|
evaluation, err = manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionRunnable, evaluation.Decision)
|
|
snapshot, err := manager.Unit(unitB)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.StatusStarted, snapshot.Status())
|
|
}
|
|
|
|
func TestOutcome_Terminal(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, test := range []struct {
|
|
name string
|
|
outcome unit.Outcome
|
|
terminal bool
|
|
}{
|
|
{name: "not registered", outcome: unit.OutcomeNotRegistered},
|
|
{name: "pending", outcome: unit.OutcomePending},
|
|
{name: "running", outcome: unit.OutcomeRunning},
|
|
{name: "succeeded", outcome: unit.OutcomeSucceeded, terminal: true},
|
|
{name: "failed", outcome: unit.OutcomeFailed, terminal: true},
|
|
{name: "timed out", outcome: unit.OutcomeTimedOut, terminal: true},
|
|
{name: "skipped", outcome: unit.OutcomeSkipped, terminal: true},
|
|
{name: "canceled", outcome: unit.OutcomeCanceled, terminal: true},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
require.Equal(t, test.terminal, test.outcome.Terminal())
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestOutcome_String(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
require.Equal(t, "not registered", unit.OutcomeNotRegistered.String())
|
|
require.Equal(t, "timed_out", unit.OutcomeTimedOut.String())
|
|
}
|
|
|
|
// TestManager_EvaluateRequirementByOutcome pins the decision for every
|
|
// requirement and prerequisite outcome pair.
|
|
func TestManager_EvaluateRequirementByOutcome(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
decisions := map[unit.Requirement]map[unit.Outcome]unit.Decision{
|
|
unit.RequirementSuccess: {
|
|
unit.OutcomePending: unit.DecisionWaiting,
|
|
unit.OutcomeRunning: unit.DecisionWaiting,
|
|
unit.OutcomeSucceeded: unit.DecisionRunnable,
|
|
unit.OutcomeFailed: unit.DecisionSkip,
|
|
unit.OutcomeTimedOut: unit.DecisionSkip,
|
|
unit.OutcomeSkipped: unit.DecisionSkip,
|
|
unit.OutcomeCanceled: unit.DecisionWaiting,
|
|
},
|
|
unit.RequirementCompletion: {
|
|
unit.OutcomePending: unit.DecisionWaiting,
|
|
unit.OutcomeRunning: unit.DecisionWaiting,
|
|
unit.OutcomeSucceeded: unit.DecisionRunnable,
|
|
unit.OutcomeFailed: unit.DecisionRunnable,
|
|
unit.OutcomeTimedOut: unit.DecisionRunnable,
|
|
unit.OutcomeSkipped: unit.DecisionRunnable,
|
|
unit.OutcomeCanceled: unit.DecisionWaiting,
|
|
},
|
|
}
|
|
|
|
for requirement, byOutcome := range decisions {
|
|
for outcome, want := range byOutcome {
|
|
t.Run(fmt.Sprintf("%s/%s", requirement, outcome), func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := conditionalManager(t, requirement)
|
|
if outcome != unit.OutcomePending {
|
|
require.NoError(t, manager.UpdateOutcome(unitB, outcome))
|
|
}
|
|
|
|
evaluation, err := manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, want, evaluation.Decision)
|
|
if want == unit.DecisionRunnable {
|
|
require.Empty(t, evaluation.UnmetDependencies)
|
|
return
|
|
}
|
|
require.Equal(t, []unit.ConditionalDependency{{
|
|
Unit: unitA,
|
|
DependsOn: unitB,
|
|
Requirement: requirement,
|
|
CurrentOutcome: outcome,
|
|
}}, evaluation.UnmetDependencies)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestManager_Evaluate(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("NoDependenciesIsRunnable", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
require.NoError(t, manager.Register(unitA))
|
|
|
|
evaluation, err := manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionRunnable, evaluation.Decision)
|
|
require.Empty(t, evaluation.UnmetDependencies)
|
|
})
|
|
|
|
t.Run("SuccessWaitsThenRuns", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := conditionalManager(t, unit.RequirementSuccess)
|
|
|
|
evaluation, err := manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionWaiting, evaluation.Decision)
|
|
require.Equal(t, unit.OutcomePending, evaluation.UnmetDependencies[0].CurrentOutcome)
|
|
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeRunning))
|
|
evaluation, err = manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionWaiting, evaluation.Decision)
|
|
require.Equal(t, unit.OutcomeRunning, evaluation.UnmetDependencies[0].CurrentOutcome)
|
|
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeSucceeded))
|
|
evaluation, err = manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionRunnable, evaluation.Decision)
|
|
require.Empty(t, evaluation.UnmetDependencies)
|
|
})
|
|
|
|
t.Run("UnregisteredPrerequisiteIsRejected", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
require.NoError(t, manager.Register(unitA))
|
|
err := manager.AddConditionalDependency(unitA, unitB, unit.RequirementSuccess)
|
|
require.ErrorIs(t, err, unit.ErrUnitNotFound)
|
|
|
|
// No edge was added, so the dependent is not left waiting on it.
|
|
evaluation, err := manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionRunnable, evaluation.Decision)
|
|
require.Empty(t, evaluation.UnmetDependencies)
|
|
})
|
|
|
|
t.Run("CanceledPrerequisiteKeepsWaiting", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, requirement := range []unit.Requirement{unit.RequirementSuccess, unit.RequirementCompletion} {
|
|
manager := conditionalManager(t, requirement)
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeRunning))
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeCanceled))
|
|
|
|
evaluation, err := manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionWaiting, evaluation.Decision, "requirement %s", requirement)
|
|
require.Equal(t, unit.OutcomeCanceled, evaluation.UnmetDependencies[0].CurrentOutcome)
|
|
}
|
|
})
|
|
|
|
t.Run("MixedRequirements", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
for _, id := range []unit.ID{unitA, unitB, unitC} {
|
|
require.NoError(t, manager.Register(id))
|
|
}
|
|
require.NoError(t, manager.AddConditionalDependency(unitA, unitB, unit.RequirementSuccess))
|
|
require.NoError(t, manager.AddConditionalDependency(unitA, unitC, unit.RequirementCompletion))
|
|
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeSucceeded))
|
|
require.NoError(t, manager.UpdateOutcome(unitC, unit.OutcomeRunning))
|
|
evaluation, err := manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionWaiting, evaluation.Decision)
|
|
require.Equal(t, []unit.ID{unitC}, conditionalDependencyIDs(evaluation.UnmetDependencies))
|
|
|
|
// A failed completion prerequisite releases rather than skips.
|
|
require.NoError(t, manager.UpdateOutcome(unitC, unit.OutcomeFailed))
|
|
evaluation, err = manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionRunnable, evaluation.Decision)
|
|
})
|
|
|
|
t.Run("SkipIsDecidedOnFirstFailure", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
for _, id := range []unit.ID{unitA, unitB, unitC} {
|
|
require.NoError(t, manager.Register(id))
|
|
}
|
|
require.NoError(t, manager.AddConditionalDependency(unitA, unitB, unit.RequirementSuccess))
|
|
require.NoError(t, manager.AddConditionalDependency(unitA, unitC, unit.RequirementSuccess))
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeRunning))
|
|
require.NoError(t, manager.UpdateOutcome(unitC, unit.OutcomeFailed))
|
|
|
|
evaluation, err := manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionSkip, evaluation.Decision)
|
|
require.Equal(t, []unit.ConditionalDependency{
|
|
{Unit: unitA, DependsOn: unitB, Requirement: unit.RequirementSuccess, CurrentOutcome: unit.OutcomeRunning},
|
|
{Unit: unitA, DependsOn: unitC, Requirement: unit.RequirementSuccess, CurrentOutcome: unit.OutcomeFailed},
|
|
}, evaluation.UnmetDependencies)
|
|
|
|
// The other prerequisite finishing later does not change the decision.
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeSucceeded))
|
|
evaluation, err = manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionSkip, evaluation.Decision)
|
|
require.Equal(t, []unit.ID{unitC}, conditionalDependencyIDs(evaluation.UnmetDependencies))
|
|
})
|
|
|
|
t.Run("UnmetDependenciesAreSorted", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
for _, id := range []unit.ID{unitA, unitB, unitC, unitD} {
|
|
require.NoError(t, manager.Register(id))
|
|
}
|
|
require.NoError(t, manager.AddConditionalDependency(unitA, unitD, unit.RequirementCompletion))
|
|
require.NoError(t, manager.AddConditionalDependency(unitA, unitB, unit.RequirementSuccess))
|
|
require.NoError(t, manager.AddConditionalDependency(unitA, unitC, unit.RequirementCompletion))
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeFailed))
|
|
|
|
evaluation, err := manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionSkip, evaluation.Decision)
|
|
require.Equal(t, []unit.ID{unitB, unitC, unitD}, conditionalDependencyIDs(evaluation.UnmetDependencies))
|
|
})
|
|
|
|
t.Run("SkippedPropagatesByRequirement", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
for _, id := range []unit.ID{unitA, unitB, unitC, unitD} {
|
|
require.NoError(t, manager.Register(id))
|
|
}
|
|
require.NoError(t, manager.AddConditionalDependency(unitB, unitA, unit.RequirementSuccess))
|
|
require.NoError(t, manager.AddConditionalDependency(unitC, unitB, unit.RequirementCompletion))
|
|
require.NoError(t, manager.AddConditionalDependency(unitD, unitB, unit.RequirementSuccess))
|
|
require.NoError(t, manager.UpdateOutcome(unitA, unit.OutcomeFailed))
|
|
|
|
evaluation, err := manager.Evaluate(unitB)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionSkip, evaluation.Decision)
|
|
|
|
// The manager does not record the skip itself. Until the caller does,
|
|
// units downstream of B keep waiting.
|
|
for _, id := range []unit.ID{unitC, unitD} {
|
|
evaluation, err = manager.Evaluate(id)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionWaiting, evaluation.Decision)
|
|
}
|
|
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeSkipped))
|
|
evaluation, err = manager.Evaluate(unitC)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionRunnable, evaluation.Decision)
|
|
evaluation, err = manager.Evaluate(unitD)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionSkip, evaluation.Decision)
|
|
})
|
|
|
|
t.Run("Validation", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
_, err := manager.Evaluate("")
|
|
require.ErrorIs(t, err, unit.ErrUnitIDRequired)
|
|
_, err = manager.Evaluate(unitA)
|
|
require.ErrorIs(t, err, unit.ErrUnitNotFound)
|
|
})
|
|
}
|
|
|
|
func TestManager_WaitForDecision(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("ReturnsAtOnceWhenDecided", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx := testutil.Context(t, testutil.WaitShort)
|
|
manager := conditionalManager(t, unit.RequirementSuccess)
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeSucceeded))
|
|
|
|
evaluation, err := manager.WaitForDecision(ctx, unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionRunnable, evaluation.Decision)
|
|
|
|
require.NoError(t, manager.Register(unitC))
|
|
evaluation, err = manager.WaitForDecision(ctx, unitC)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionRunnable, evaluation.Decision)
|
|
})
|
|
|
|
t.Run("WakesWhenRunnable", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx := testutil.Context(t, testutil.WaitShort)
|
|
manager := conditionalManager(t, unit.RequirementSuccess)
|
|
result := make(chan unit.Evaluation, 1)
|
|
errCh := make(chan error, 1)
|
|
go func() {
|
|
evaluation, err := manager.WaitForDecision(ctx, unitA)
|
|
result <- evaluation
|
|
errCh <- err
|
|
}()
|
|
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeSucceeded))
|
|
require.Equal(t, unit.DecisionRunnable, testutil.RequireReceive(ctx, t, result).Decision)
|
|
require.NoError(t, testutil.RequireReceive(ctx, t, errCh))
|
|
})
|
|
|
|
t.Run("WakesWhenSkipped", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx := testutil.Context(t, testutil.WaitShort)
|
|
manager := conditionalManager(t, unit.RequirementSuccess)
|
|
result := make(chan unit.Evaluation, 1)
|
|
errCh := make(chan error, 1)
|
|
go func() {
|
|
evaluation, err := manager.WaitForDecision(ctx, unitA)
|
|
result <- evaluation
|
|
errCh <- err
|
|
}()
|
|
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeFailed))
|
|
require.Equal(t, unit.DecisionSkip, testutil.RequireReceive(ctx, t, result).Decision)
|
|
require.NoError(t, testutil.RequireReceive(ctx, t, errCh))
|
|
})
|
|
|
|
t.Run("WakesWhenEdgeAdded", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx := testutil.Context(t, testutil.WaitShort)
|
|
manager := conditionalManager(t, unit.RequirementSuccess)
|
|
require.NoError(t, manager.Register(unitC))
|
|
require.NoError(t, manager.UpdateOutcome(unitC, unit.OutcomeFailed))
|
|
result := make(chan unit.Evaluation, 1)
|
|
go func() {
|
|
evaluation, _ := manager.WaitForDecision(ctx, unitA)
|
|
result <- evaluation
|
|
}()
|
|
|
|
// A new success edge to an already failed unit makes A skipped.
|
|
require.NoError(t, manager.AddConditionalDependency(unitA, unitC, unit.RequirementSuccess))
|
|
require.Equal(t, unit.DecisionSkip, testutil.RequireReceive(ctx, t, result).Decision)
|
|
})
|
|
|
|
t.Run("ContextCanceled", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
manager := conditionalManager(t, unit.RequirementSuccess)
|
|
require.NoError(t, manager.UpdateOutcome(unitB, unit.OutcomeRunning))
|
|
|
|
_, err := manager.WaitForDecision(ctx, unitA)
|
|
require.ErrorIs(t, err, context.Canceled)
|
|
|
|
// Nothing changed because the wait was abandoned.
|
|
snapshot, err := manager.Unit(unitB)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.OutcomeRunning, snapshot.Outcome())
|
|
evaluation, err := manager.Evaluate(unitA)
|
|
require.NoError(t, err)
|
|
require.Equal(t, unit.DecisionWaiting, evaluation.Decision)
|
|
})
|
|
|
|
t.Run("Validation", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
manager := unit.NewManager()
|
|
_, err := manager.WaitForDecision(context.Background(), unitA)
|
|
require.ErrorIs(t, err, unit.ErrUnitNotFound)
|
|
_, err = manager.WaitForDecision(context.Background(), "")
|
|
require.ErrorIs(t, err, unit.ErrUnitIDRequired)
|
|
})
|
|
}
|
|
|
|
func TestManager_WaitForDecision_ManyWaiters(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const count = 50
|
|
ctx := testutil.Context(t, testutil.WaitMedium)
|
|
manager := unit.NewManager()
|
|
|
|
dependents := make([]unit.ID, 0, count)
|
|
prerequisites := make([]unit.ID, 0, count)
|
|
for i := range count {
|
|
dependent := unit.ID(fmt.Sprintf("dependent-%02d", i))
|
|
prerequisite := unit.ID(fmt.Sprintf("prerequisite-%02d", i))
|
|
require.NoError(t, manager.Register(dependent))
|
|
require.NoError(t, manager.Register(prerequisite))
|
|
require.NoError(t, manager.AddConditionalDependency(dependent, prerequisite, unit.RequirementSuccess))
|
|
dependents = append(dependents, dependent)
|
|
prerequisites = append(prerequisites, prerequisite)
|
|
}
|
|
|
|
type result struct {
|
|
id unit.ID
|
|
evaluation unit.Evaluation
|
|
err error
|
|
}
|
|
results := make(chan result, count)
|
|
for _, id := range dependents {
|
|
go func() {
|
|
evaluation, err := manager.WaitForDecision(ctx, id)
|
|
results <- result{id: id, evaluation: evaluation, err: err}
|
|
}()
|
|
}
|
|
|
|
// One update releases exactly one waiter.
|
|
require.NoError(t, manager.UpdateOutcome(prerequisites[0], unit.OutcomeSucceeded))
|
|
first := testutil.RequireReceive(ctx, t, results)
|
|
require.NoError(t, first.err)
|
|
require.Equal(t, dependents[0], first.id)
|
|
require.Equal(t, unit.DecisionRunnable, first.evaluation.Decision)
|
|
select {
|
|
case extra := <-results:
|
|
t.Fatalf("unexpected result for %s", extra.id)
|
|
default:
|
|
}
|
|
|
|
// The rest wake one by one as their own prerequisite finishes.
|
|
released := map[unit.ID]bool{dependents[0]: true}
|
|
for i := 1; i < count; i++ {
|
|
require.NoError(t, manager.UpdateOutcome(prerequisites[i], unit.OutcomeFailed))
|
|
}
|
|
for i := 1; i < count; i++ {
|
|
got := testutil.RequireReceive(ctx, t, results)
|
|
require.NoError(t, got.err)
|
|
require.Equal(t, unit.DecisionSkip, got.evaluation.Decision, "unit %s", got.id)
|
|
require.False(t, released[got.id], "unit %s released twice", got.id)
|
|
released[got.id] = true
|
|
}
|
|
require.Len(t, released, count)
|
|
}
|
|
|
|
func conditionalManager(t *testing.T, requirement unit.Requirement) *unit.Manager {
|
|
t.Helper()
|
|
|
|
manager := unit.NewManager()
|
|
require.NoError(t, manager.Register(unitA))
|
|
require.NoError(t, manager.Register(unitB))
|
|
require.NoError(t, manager.AddConditionalDependency(unitA, unitB, requirement))
|
|
return manager
|
|
}
|
|
|
|
func conditionalDependencyIDs(dependencies []unit.ConditionalDependency) []unit.ID {
|
|
ids := make([]unit.ID, 0, len(dependencies))
|
|
for _, dependency := range dependencies {
|
|
ids = append(ids, dependency.DependsOn)
|
|
}
|
|
return ids
|
|
}
|