feat: runtime manager

rtmanager/internal/domain/runtime/transitions_test.go

@@ -0,0 +1,88 @@
+package runtime
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestTransitionAllowed(t *testing.T) {
+	cases := []struct {
+		from Status
+		to   Status
+	}{
+		{StatusRunning, StatusStopped},
+		{StatusRunning, StatusRemoved},
+		{StatusStopped, StatusRunning},
+		{StatusStopped, StatusRemoved},
+	}
+
+	for _, tc := range cases {
+		assert.NoErrorf(t, Transition(tc.from, tc.to),
+			"expected %q -> %q allowed", tc.from, tc.to)
+	}
+}
+
+func TestTransitionRejected(t *testing.T) {
+	cases := []struct {
+		from Status
+		to   Status
+	}{
+		{StatusRemoved, StatusRunning},
+		{StatusRemoved, StatusStopped},
+		{StatusRemoved, StatusRemoved},
+		{StatusRunning, StatusRunning},
+		{StatusStopped, StatusStopped},
+		{Status("unknown"), StatusRunning},
+		{StatusRunning, Status("unknown")},
+		{Status(""), Status("")},
+	}
+
+	for _, tc := range cases {
+		err := Transition(tc.from, tc.to)
+		require.Errorf(t, err, "expected %q -> %q rejected", tc.from, tc.to)
+		assert.ErrorIs(t, err, ErrInvalidTransition)
+
+		var transitionErr *InvalidTransitionError
+		require.True(t, errors.As(err, &transitionErr),
+			"expected *InvalidTransitionError for %q -> %q", tc.from, tc.to)
+		assert.Equal(t, tc.from, transitionErr.From)
+		assert.Equal(t, tc.to, transitionErr.To)
+	}
+}
+
+func TestAllowedTransitionsReturnsCopy(t *testing.T) {
+	first := AllowedTransitions()
+	require.NotEmpty(t, first)
+
+	for from := range first {
+		first[from] = nil
+	}
+
+	second := AllowedTransitions()
+	assert.NotEmpty(t, second[StatusRunning],
+		"AllowedTransitions must return an independent map per call")
+}
+
+func TestAllowedTransitionsCoversFourPairs(t *testing.T) {
+	transitions := AllowedTransitions()
+
+	assert.ElementsMatch(t,
+		[]Status{StatusStopped, StatusRemoved},
+		transitions[StatusRunning],
+	)
+	assert.ElementsMatch(t,
+		[]Status{StatusRunning, StatusRemoved},
+		transitions[StatusStopped],
+	)
+	assert.Empty(t, transitions[StatusRemoved],
+		"removed has no outgoing transitions")
+}
+
+func TestInvalidTransitionErrorMessage(t *testing.T) {
+	err := &InvalidTransitionError{From: StatusRunning, To: Status("bogus")}
+	assert.Contains(t, err.Error(), "running")
+	assert.Contains(t, err.Error(), "bogus")
+}