Ilia Denisov
438 lines
14 KiB
Go
438 lines
14 KiB
Go
package adminforce_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"galaxy/gamemaster/internal/domain/operation"
|
|
"galaxy/gamemaster/internal/domain/runtime"
|
|
"galaxy/gamemaster/internal/ports"
|
|
"galaxy/gamemaster/internal/service/adminforce"
|
|
"galaxy/gamemaster/internal/service/turngeneration"
|
|
"galaxy/gamemaster/internal/telemetry"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// --- test doubles -----------------------------------------------------
|
|
|
|
type fakeRuntimeRecords struct {
|
|
mu sync.Mutex
|
|
stored map[string]runtime.RuntimeRecord
|
|
schErr error
|
|
scheds []ports.UpdateSchedulingInput
|
|
}
|
|
|
|
func newFakeRuntimeRecords() *fakeRuntimeRecords {
|
|
return &fakeRuntimeRecords{stored: map[string]runtime.RuntimeRecord{}}
|
|
}
|
|
|
|
func (s *fakeRuntimeRecords) seed(record runtime.RuntimeRecord) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.stored[record.GameID] = record
|
|
}
|
|
|
|
func (s *fakeRuntimeRecords) Get(_ context.Context, gameID string) (runtime.RuntimeRecord, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
record, ok := s.stored[gameID]
|
|
if !ok {
|
|
return runtime.RuntimeRecord{}, runtime.ErrNotFound
|
|
}
|
|
return record, nil
|
|
}
|
|
|
|
func (s *fakeRuntimeRecords) Insert(context.Context, runtime.RuntimeRecord) error {
|
|
return errors.New("not used")
|
|
}
|
|
func (s *fakeRuntimeRecords) UpdateStatus(context.Context, ports.UpdateStatusInput) error {
|
|
return errors.New("not used")
|
|
}
|
|
func (s *fakeRuntimeRecords) UpdateScheduling(_ context.Context, input ports.UpdateSchedulingInput) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if s.schErr != nil {
|
|
return s.schErr
|
|
}
|
|
record, ok := s.stored[input.GameID]
|
|
if !ok {
|
|
return runtime.ErrNotFound
|
|
}
|
|
if input.NextGenerationAt != nil {
|
|
next := *input.NextGenerationAt
|
|
record.NextGenerationAt = &next
|
|
} else {
|
|
record.NextGenerationAt = nil
|
|
}
|
|
record.SkipNextTick = input.SkipNextTick
|
|
record.CurrentTurn = input.CurrentTurn
|
|
record.UpdatedAt = input.Now
|
|
s.stored[input.GameID] = record
|
|
s.scheds = append(s.scheds, input)
|
|
return nil
|
|
}
|
|
func (s *fakeRuntimeRecords) UpdateImage(context.Context, ports.UpdateImageInput) error {
|
|
return errors.New("not used")
|
|
}
|
|
func (s *fakeRuntimeRecords) UpdateEngineHealth(context.Context, ports.UpdateEngineHealthInput) error {
|
|
return errors.New("not used")
|
|
}
|
|
func (s *fakeRuntimeRecords) Delete(context.Context, string) error {
|
|
return errors.New("not used")
|
|
}
|
|
func (s *fakeRuntimeRecords) ListDueRunning(context.Context, time.Time) ([]runtime.RuntimeRecord, error) {
|
|
return nil, errors.New("not used")
|
|
}
|
|
func (s *fakeRuntimeRecords) ListByStatus(context.Context, runtime.Status) ([]runtime.RuntimeRecord, error) {
|
|
return nil, errors.New("not used")
|
|
}
|
|
func (s *fakeRuntimeRecords) List(context.Context) ([]runtime.RuntimeRecord, error) {
|
|
return nil, errors.New("not used")
|
|
}
|
|
|
|
type fakeOperationLogs struct {
|
|
mu sync.Mutex
|
|
entries []operation.OperationEntry
|
|
}
|
|
|
|
func (s *fakeOperationLogs) Append(_ context.Context, entry operation.OperationEntry) (int64, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if err := entry.Validate(); err != nil {
|
|
return 0, err
|
|
}
|
|
s.entries = append(s.entries, entry)
|
|
return int64(len(s.entries)), nil
|
|
}
|
|
func (s *fakeOperationLogs) ListByGame(context.Context, string, int) ([]operation.OperationEntry, error) {
|
|
return nil, errors.New("not used")
|
|
}
|
|
func (s *fakeOperationLogs) snapshot() []operation.OperationEntry {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
out := make([]operation.OperationEntry, len(s.entries))
|
|
copy(out, s.entries)
|
|
return out
|
|
}
|
|
func (s *fakeOperationLogs) lastEntry() (operation.OperationEntry, bool) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if len(s.entries) == 0 {
|
|
return operation.OperationEntry{}, false
|
|
}
|
|
return s.entries[len(s.entries)-1], true
|
|
}
|
|
|
|
type fakeTurnGenerator struct {
|
|
mu sync.Mutex
|
|
calls []turngeneration.Input
|
|
result turngeneration.Result
|
|
err error
|
|
}
|
|
|
|
func (s *fakeTurnGenerator) Handle(_ context.Context, input turngeneration.Input) (turngeneration.Result, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.calls = append(s.calls, input)
|
|
return s.result, s.err
|
|
}
|
|
|
|
// --- harness ----------------------------------------------------------
|
|
|
|
type harness struct {
|
|
t *testing.T
|
|
runtime *fakeRuntimeRecords
|
|
logs *fakeOperationLogs
|
|
turn *fakeTurnGenerator
|
|
telemetry *telemetry.Runtime
|
|
now time.Time
|
|
service *adminforce.Service
|
|
}
|
|
|
|
func newHarness(t *testing.T) *harness {
|
|
t.Helper()
|
|
telemetryRuntime, err := telemetry.NewWithProviders(nil, nil)
|
|
require.NoError(t, err)
|
|
h := &harness{
|
|
t: t,
|
|
runtime: newFakeRuntimeRecords(),
|
|
logs: &fakeOperationLogs{},
|
|
turn: &fakeTurnGenerator{},
|
|
telemetry: telemetryRuntime,
|
|
now: time.Date(2026, time.May, 1, 12, 0, 0, 0, time.UTC),
|
|
}
|
|
service, err := adminforce.NewService(adminforce.Dependencies{
|
|
RuntimeRecords: h.runtime,
|
|
OperationLogs: h.logs,
|
|
TurnGeneration: h.turn,
|
|
Telemetry: h.telemetry,
|
|
Clock: func() time.Time { return h.now },
|
|
})
|
|
require.NoError(t, err)
|
|
h.service = service
|
|
return h
|
|
}
|
|
|
|
func (h *harness) seedRunningRecord() runtime.RuntimeRecord {
|
|
created := h.now.Add(-time.Hour)
|
|
started := h.now.Add(-30 * time.Minute)
|
|
next := h.now.Add(30 * time.Minute)
|
|
record := runtime.RuntimeRecord{
|
|
GameID: "game-001",
|
|
Status: runtime.StatusRunning,
|
|
EngineEndpoint: "http://galaxy-game-game-001:8080",
|
|
CurrentImageRef: "ghcr.io/galaxy/game:v1.2.3",
|
|
CurrentEngineVersion: "v1.2.3",
|
|
TurnSchedule: "0 18 * * *",
|
|
CurrentTurn: 5,
|
|
NextGenerationAt: &next,
|
|
EngineHealth: "healthy",
|
|
CreatedAt: created,
|
|
UpdatedAt: started,
|
|
StartedAt: &started,
|
|
}
|
|
h.runtime.seed(record)
|
|
return record
|
|
}
|
|
|
|
func baseInput() adminforce.Input {
|
|
return adminforce.Input{
|
|
GameID: "game-001",
|
|
OpSource: operation.OpSourceAdminRest,
|
|
SourceRef: "req-force-001",
|
|
}
|
|
}
|
|
|
|
// --- tests ------------------------------------------------------------
|
|
|
|
func TestNewServiceRejectsMissingDeps(t *testing.T) {
|
|
telemetryRuntime, err := telemetry.NewWithProviders(nil, nil)
|
|
require.NoError(t, err)
|
|
cases := []struct {
|
|
name string
|
|
mut func(*adminforce.Dependencies)
|
|
}{
|
|
{"runtime records", func(d *adminforce.Dependencies) { d.RuntimeRecords = nil }},
|
|
{"operation logs", func(d *adminforce.Dependencies) { d.OperationLogs = nil }},
|
|
{"turn generation", func(d *adminforce.Dependencies) { d.TurnGeneration = nil }},
|
|
{"telemetry", func(d *adminforce.Dependencies) { d.Telemetry = nil }},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
deps := adminforce.Dependencies{
|
|
RuntimeRecords: newFakeRuntimeRecords(),
|
|
OperationLogs: &fakeOperationLogs{},
|
|
TurnGeneration: &fakeTurnGenerator{},
|
|
Telemetry: telemetryRuntime,
|
|
}
|
|
tc.mut(&deps)
|
|
service, err := adminforce.NewService(deps)
|
|
require.Error(t, err)
|
|
require.Nil(t, service)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHandleHappyPathSetsSkipNextTick(t *testing.T) {
|
|
h := newHarness(t)
|
|
original := h.seedRunningRecord()
|
|
|
|
postTurn := original
|
|
postTurn.CurrentTurn = original.CurrentTurn + 1
|
|
nextGen := h.now.Add(time.Hour)
|
|
postTurn.NextGenerationAt = &nextGen
|
|
postTurn.SkipNextTick = false
|
|
h.turn.result = turngeneration.Result{
|
|
Record: postTurn,
|
|
Trigger: turngeneration.TriggerForce,
|
|
Outcome: operation.OutcomeSuccess,
|
|
}
|
|
|
|
result, err := h.service.Handle(context.Background(), baseInput())
|
|
require.NoError(t, err)
|
|
require.True(t, result.IsSuccess(), "want success, got %+v", result)
|
|
assert.True(t, result.SkipScheduled)
|
|
|
|
// turngeneration.Handle invoked once with TriggerForce.
|
|
require.Len(t, h.turn.calls, 1)
|
|
assert.Equal(t, turngeneration.TriggerForce, h.turn.calls[0].Trigger)
|
|
assert.Equal(t, operation.OpSourceAdminRest, h.turn.calls[0].OpSource)
|
|
assert.Equal(t, "req-force-001", h.turn.calls[0].SourceRef)
|
|
|
|
// Exactly one UpdateScheduling call with skip=true and identical
|
|
// next_generation_at / current_turn from the inner result.
|
|
require.Len(t, h.runtime.scheds, 1)
|
|
scheds := h.runtime.scheds[0]
|
|
assert.True(t, scheds.SkipNextTick)
|
|
require.NotNil(t, scheds.NextGenerationAt)
|
|
assert.True(t, scheds.NextGenerationAt.Equal(nextGen))
|
|
assert.Equal(t, postTurn.CurrentTurn, scheds.CurrentTurn)
|
|
|
|
// Driver entry op_kind=force_next_turn, outcome=success.
|
|
entry, ok := h.logs.lastEntry()
|
|
require.True(t, ok)
|
|
assert.Equal(t, operation.OpKindForceNextTurn, entry.OpKind)
|
|
assert.Equal(t, operation.OutcomeSuccess, entry.Outcome)
|
|
assert.Equal(t, "req-force-001", entry.SourceRef)
|
|
}
|
|
|
|
func TestHandleSetsSkipEvenWhenFinished(t *testing.T) {
|
|
h := newHarness(t)
|
|
original := h.seedRunningRecord()
|
|
|
|
// Inner turn-generation finished the game: NextGenerationAt is
|
|
// cleared, status flipped to finished. adminforce still issues the
|
|
// scheduling write per stage 17 D3.
|
|
finished := original
|
|
finished.Status = runtime.StatusFinished
|
|
finished.NextGenerationAt = nil
|
|
finished.CurrentTurn = original.CurrentTurn + 1
|
|
h.turn.result = turngeneration.Result{
|
|
Record: finished,
|
|
Trigger: turngeneration.TriggerForce,
|
|
Finished: true,
|
|
Outcome: operation.OutcomeSuccess,
|
|
}
|
|
|
|
result, err := h.service.Handle(context.Background(), baseInput())
|
|
require.NoError(t, err)
|
|
require.True(t, result.IsSuccess())
|
|
require.Len(t, h.runtime.scheds, 1, "skip must still be written even when finished")
|
|
assert.True(t, h.runtime.scheds[0].SkipNextTick)
|
|
assert.Nil(t, h.runtime.scheds[0].NextGenerationAt, "must propagate inner result's nil next-gen")
|
|
assert.Equal(t, finished.CurrentTurn, h.runtime.scheds[0].CurrentTurn)
|
|
}
|
|
|
|
func TestHandlePropagatesInnerFailure(t *testing.T) {
|
|
h := newHarness(t)
|
|
h.seedRunningRecord()
|
|
|
|
h.turn.result = turngeneration.Result{
|
|
Trigger: turngeneration.TriggerForce,
|
|
Outcome: operation.OutcomeFailure,
|
|
ErrorCode: turngeneration.ErrorCodeEngineUnreachable,
|
|
ErrorMessage: "engine 503",
|
|
}
|
|
|
|
result, err := h.service.Handle(context.Background(), baseInput())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeFailure, result.Outcome)
|
|
assert.Equal(t, adminforce.ErrorCodeEngineUnreachable, result.ErrorCode)
|
|
assert.False(t, result.SkipScheduled)
|
|
assert.Empty(t, h.runtime.scheds, "scheduling must not run after failure")
|
|
|
|
// Driver entry recorded with the propagated error code.
|
|
entry, ok := h.logs.lastEntry()
|
|
require.True(t, ok)
|
|
assert.Equal(t, operation.OpKindForceNextTurn, entry.OpKind)
|
|
assert.Equal(t, operation.OutcomeFailure, entry.Outcome)
|
|
assert.Equal(t, adminforce.ErrorCodeEngineUnreachable, entry.ErrorCode)
|
|
}
|
|
|
|
func TestHandlePropagatesRuntimeNotRunning(t *testing.T) {
|
|
h := newHarness(t)
|
|
h.seedRunningRecord()
|
|
|
|
h.turn.result = turngeneration.Result{
|
|
Trigger: turngeneration.TriggerForce,
|
|
Outcome: operation.OutcomeFailure,
|
|
ErrorCode: turngeneration.ErrorCodeRuntimeNotRunning,
|
|
ErrorMessage: "runtime status is \"stopped\"",
|
|
}
|
|
|
|
result, err := h.service.Handle(context.Background(), baseInput())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, adminforce.ErrorCodeRuntimeNotRunning, result.ErrorCode)
|
|
}
|
|
|
|
func TestHandleSchedulingFailureAfterTurn(t *testing.T) {
|
|
h := newHarness(t)
|
|
original := h.seedRunningRecord()
|
|
|
|
postTurn := original
|
|
postTurn.CurrentTurn = original.CurrentTurn + 1
|
|
h.turn.result = turngeneration.Result{
|
|
Record: postTurn,
|
|
Trigger: turngeneration.TriggerForce,
|
|
Outcome: operation.OutcomeSuccess,
|
|
}
|
|
h.runtime.schErr = errors.New("connection lost")
|
|
|
|
result, err := h.service.Handle(context.Background(), baseInput())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeFailure, result.Outcome)
|
|
assert.Equal(t, adminforce.ErrorCodeServiceUnavailable, result.ErrorCode)
|
|
assert.False(t, result.SkipScheduled)
|
|
|
|
// The driver entry records failure even though turn-generation
|
|
// committed successfully.
|
|
entry, ok := h.logs.lastEntry()
|
|
require.True(t, ok)
|
|
assert.Equal(t, operation.OutcomeFailure, entry.Outcome)
|
|
assert.Equal(t, adminforce.ErrorCodeServiceUnavailable, entry.ErrorCode)
|
|
}
|
|
|
|
func TestHandleTurnGeneratorReturnsError(t *testing.T) {
|
|
h := newHarness(t)
|
|
h.seedRunningRecord()
|
|
h.turn.err = errors.New("nil context")
|
|
|
|
result, err := h.service.Handle(context.Background(), baseInput())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeFailure, result.Outcome)
|
|
assert.Equal(t, adminforce.ErrorCodeInternal, result.ErrorCode)
|
|
assert.Empty(t, h.runtime.scheds)
|
|
}
|
|
|
|
func TestHandleInvalidRequest(t *testing.T) {
|
|
h := newHarness(t)
|
|
|
|
input := baseInput()
|
|
input.GameID = ""
|
|
result, err := h.service.Handle(context.Background(), input)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeFailure, result.Outcome)
|
|
assert.Equal(t, adminforce.ErrorCodeInvalidRequest, result.ErrorCode)
|
|
assert.Empty(t, h.turn.calls, "turn generator must not be called on invalid input")
|
|
assert.Empty(t, h.logs.snapshot(), "audit entry skipped when game id missing")
|
|
}
|
|
|
|
func TestHandleNilContextReturnsError(t *testing.T) {
|
|
h := newHarness(t)
|
|
_, err := h.service.Handle(nil, baseInput()) //nolint:staticcheck // guard test
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestHandleDefaultsOpSource(t *testing.T) {
|
|
h := newHarness(t)
|
|
h.seedRunningRecord()
|
|
|
|
postTurn := runtime.RuntimeRecord{
|
|
GameID: "game-001",
|
|
Status: runtime.StatusRunning,
|
|
CurrentTurn: 7,
|
|
}
|
|
h.turn.result = turngeneration.Result{
|
|
Record: postTurn,
|
|
Trigger: turngeneration.TriggerForce,
|
|
Outcome: operation.OutcomeSuccess,
|
|
}
|
|
|
|
input := baseInput()
|
|
input.OpSource = ""
|
|
result, err := h.service.Handle(context.Background(), input)
|
|
require.NoError(t, err)
|
|
require.True(t, result.IsSuccess())
|
|
require.Len(t, h.turn.calls, 1)
|
|
assert.Equal(t, operation.OpSourceAdminRest, h.turn.calls[0].OpSource)
|
|
|
|
entry, ok := h.logs.lastEntry()
|
|
require.True(t, ok)
|
|
assert.Equal(t, operation.OpSourceAdminRest, entry.OpSource)
|
|
}
|