Ilia Denisov
543 lines
17 KiB
Go
543 lines
17 KiB
Go
package schedulerticker_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"galaxy/gamemaster/internal/adapters/mocks"
|
|
"galaxy/gamemaster/internal/domain/operation"
|
|
"galaxy/gamemaster/internal/domain/playermapping"
|
|
"galaxy/gamemaster/internal/domain/runtime"
|
|
"galaxy/gamemaster/internal/ports"
|
|
"galaxy/gamemaster/internal/service/scheduler"
|
|
"galaxy/gamemaster/internal/service/turngeneration"
|
|
"galaxy/gamemaster/internal/telemetry"
|
|
"galaxy/gamemaster/internal/worker/schedulerticker"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"go.uber.org/mock/gomock"
|
|
)
|
|
|
|
// fakeRuntimeRecordsBackend is a minimal in-memory implementation of
|
|
// the RuntimeRecordStore subset the ticker exercises plus the
|
|
// turn-generation orchestrator hooks. The fake mirrors the runtime CAS
|
|
// semantics so the in-flight set test can run a full
|
|
// running→generation_in_progress→running cycle.
|
|
type fakeRuntimeRecordsBackend struct {
|
|
mu sync.Mutex
|
|
stored map[string]runtime.RuntimeRecord
|
|
listErr error
|
|
listCalls atomic.Int32
|
|
listCustom func(ctx context.Context, now time.Time) ([]runtime.RuntimeRecord, error)
|
|
}
|
|
|
|
func newFakeRuntimeRecordsBackend() *fakeRuntimeRecordsBackend {
|
|
return &fakeRuntimeRecordsBackend{stored: map[string]runtime.RuntimeRecord{}}
|
|
}
|
|
|
|
func (s *fakeRuntimeRecordsBackend) seed(record runtime.RuntimeRecord) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.stored[record.GameID] = record
|
|
}
|
|
|
|
func (s *fakeRuntimeRecordsBackend) 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 *fakeRuntimeRecordsBackend) Insert(_ context.Context, record runtime.RuntimeRecord) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if _, ok := s.stored[record.GameID]; ok {
|
|
return runtime.ErrConflict
|
|
}
|
|
s.stored[record.GameID] = record
|
|
return nil
|
|
}
|
|
|
|
func (s *fakeRuntimeRecordsBackend) UpdateStatus(_ context.Context, input ports.UpdateStatusInput) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
record, ok := s.stored[input.GameID]
|
|
if !ok {
|
|
return runtime.ErrNotFound
|
|
}
|
|
if record.Status != input.ExpectedFrom {
|
|
return runtime.ErrConflict
|
|
}
|
|
record.Status = input.To
|
|
record.UpdatedAt = input.Now
|
|
if input.To == runtime.StatusRunning && record.StartedAt == nil {
|
|
startedAt := input.Now
|
|
record.StartedAt = &startedAt
|
|
}
|
|
if input.To == runtime.StatusFinished {
|
|
finishedAt := input.Now
|
|
record.FinishedAt = &finishedAt
|
|
}
|
|
s.stored[input.GameID] = record
|
|
return nil
|
|
}
|
|
|
|
func (s *fakeRuntimeRecordsBackend) UpdateScheduling(_ context.Context, input ports.UpdateSchedulingInput) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
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
|
|
return nil
|
|
}
|
|
|
|
func (s *fakeRuntimeRecordsBackend) UpdateImage(_ context.Context, _ ports.UpdateImageInput) error {
|
|
return errors.New("not used in schedulerticker tests")
|
|
}
|
|
|
|
func (s *fakeRuntimeRecordsBackend) UpdateEngineHealth(_ context.Context, _ ports.UpdateEngineHealthInput) error {
|
|
return errors.New("not used in schedulerticker tests")
|
|
}
|
|
|
|
func (s *fakeRuntimeRecordsBackend) Delete(_ context.Context, gameID string) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
delete(s.stored, gameID)
|
|
return nil
|
|
}
|
|
|
|
func (s *fakeRuntimeRecordsBackend) ListDueRunning(ctx context.Context, now time.Time) ([]runtime.RuntimeRecord, error) {
|
|
s.listCalls.Add(1)
|
|
if s.listCustom != nil {
|
|
return s.listCustom(ctx, now)
|
|
}
|
|
if s.listErr != nil {
|
|
return nil, s.listErr
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
var due []runtime.RuntimeRecord
|
|
for _, record := range s.stored {
|
|
if record.Status != runtime.StatusRunning {
|
|
continue
|
|
}
|
|
if record.NextGenerationAt == nil || record.NextGenerationAt.After(now) {
|
|
continue
|
|
}
|
|
due = append(due, record)
|
|
}
|
|
return due, nil
|
|
}
|
|
|
|
func (s *fakeRuntimeRecordsBackend) ListByStatus(_ context.Context, status runtime.Status) ([]runtime.RuntimeRecord, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
var matching []runtime.RuntimeRecord
|
|
for _, record := range s.stored {
|
|
if record.Status == status {
|
|
matching = append(matching, record)
|
|
}
|
|
}
|
|
return matching, nil
|
|
}
|
|
|
|
func (s *fakeRuntimeRecordsBackend) List(_ context.Context) ([]runtime.RuntimeRecord, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
all := make([]runtime.RuntimeRecord, 0, len(s.stored))
|
|
for _, record := range s.stored {
|
|
all = append(all, record)
|
|
}
|
|
return all, nil
|
|
}
|
|
|
|
type stubMappings struct {
|
|
rows map[string][]playermapping.PlayerMapping
|
|
}
|
|
|
|
func (s *stubMappings) BulkInsert(_ context.Context, _ []playermapping.PlayerMapping) error {
|
|
return errors.New("not used")
|
|
}
|
|
|
|
func (s *stubMappings) Get(_ context.Context, _, _ string) (playermapping.PlayerMapping, error) {
|
|
return playermapping.PlayerMapping{}, errors.New("not used")
|
|
}
|
|
|
|
func (s *stubMappings) GetByRace(_ context.Context, _, _ string) (playermapping.PlayerMapping, error) {
|
|
return playermapping.PlayerMapping{}, errors.New("not used")
|
|
}
|
|
|
|
func (s *stubMappings) ListByGame(_ context.Context, gameID string) ([]playermapping.PlayerMapping, error) {
|
|
return append([]playermapping.PlayerMapping(nil), s.rows[gameID]...), nil
|
|
}
|
|
|
|
func (s *stubMappings) DeleteByGame(_ context.Context, _ string) error {
|
|
return errors.New("not used")
|
|
}
|
|
|
|
type stubLogs struct{}
|
|
|
|
func (stubLogs) Append(_ context.Context, _ operation.OperationEntry) (int64, error) { return 1, nil }
|
|
func (stubLogs) ListByGame(_ context.Context, _ string, _ int) ([]operation.OperationEntry, error) {
|
|
return nil, errors.New("not used")
|
|
}
|
|
|
|
// --- helpers ----------------------------------------------------------
|
|
|
|
func newTelemetry(t *testing.T) *telemetry.Runtime {
|
|
t.Helper()
|
|
tm, err := telemetry.NewWithProviders(nil, nil)
|
|
require.NoError(t, err)
|
|
return tm
|
|
}
|
|
|
|
func seedRunningRecord(t *testing.T, store *fakeRuntimeRecordsBackend, mappings *stubMappings, gameID string, due time.Time) {
|
|
t.Helper()
|
|
startedAt := due.Add(-1 * time.Hour)
|
|
store.seed(runtime.RuntimeRecord{
|
|
GameID: gameID,
|
|
Status: runtime.StatusRunning,
|
|
EngineEndpoint: "http://galaxy-game-" + gameID + ":8080",
|
|
CurrentImageRef: "ghcr.io/galaxy/game:v1.2.3",
|
|
CurrentEngineVersion: "v1.2.3",
|
|
TurnSchedule: "0 18 * * *",
|
|
CurrentTurn: 0,
|
|
NextGenerationAt: &due,
|
|
EngineHealth: "healthy",
|
|
CreatedAt: due.Add(-2 * time.Hour),
|
|
UpdatedAt: due.Add(-2 * time.Hour),
|
|
StartedAt: &startedAt,
|
|
})
|
|
if mappings.rows == nil {
|
|
mappings.rows = map[string][]playermapping.PlayerMapping{}
|
|
}
|
|
mappings.rows[gameID] = []playermapping.PlayerMapping{
|
|
{GameID: gameID, UserID: "user-1", RaceName: "Aelinari", EnginePlayerUUID: "uuid-1", CreatedAt: startedAt},
|
|
{GameID: gameID, UserID: "user-2", RaceName: "Drazi", EnginePlayerUUID: "uuid-2", CreatedAt: startedAt},
|
|
}
|
|
}
|
|
|
|
// --- tests ------------------------------------------------------------
|
|
|
|
func TestNewWorkerRejectsMissingDeps(t *testing.T) {
|
|
telem := newTelemetry(t)
|
|
cases := []struct {
|
|
name string
|
|
mut func(*schedulerticker.Dependencies)
|
|
}{
|
|
{"runtime records", func(d *schedulerticker.Dependencies) { d.RuntimeRecords = nil }},
|
|
{"turn generation", func(d *schedulerticker.Dependencies) { d.TurnGeneration = nil }},
|
|
{"telemetry", func(d *schedulerticker.Dependencies) { d.Telemetry = nil }},
|
|
{"non-positive interval", func(d *schedulerticker.Dependencies) { d.Interval = 0 }},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
ctrl := gomock.NewController(t)
|
|
turn := buildTurnService(t, ctrl, newFakeRuntimeRecordsBackend(), &stubMappings{}, telem)
|
|
deps := schedulerticker.Dependencies{
|
|
RuntimeRecords: newFakeRuntimeRecordsBackend(),
|
|
TurnGeneration: turn,
|
|
Telemetry: telem,
|
|
Interval: time.Second,
|
|
}
|
|
tc.mut(&deps)
|
|
worker, err := schedulerticker.NewWorker(deps)
|
|
require.Error(t, err)
|
|
require.Nil(t, worker)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTickDispatchesDueGames(t *testing.T) {
|
|
ctrl := gomock.NewController(t)
|
|
telem := newTelemetry(t)
|
|
store := newFakeRuntimeRecordsBackend()
|
|
mappings := &stubMappings{}
|
|
|
|
now := time.Date(2026, time.April, 30, 12, 0, 0, 0, time.UTC)
|
|
due := now.Add(-5 * time.Minute)
|
|
seedRunningRecord(t, store, mappings, "game-a", due)
|
|
seedRunningRecord(t, store, mappings, "game-b", due)
|
|
|
|
engine := mocks.NewMockEngineClient(ctrl)
|
|
lobbyEvents := mocks.NewMockLobbyEventsPublisher(ctrl)
|
|
notifications := mocks.NewMockNotificationIntentPublisher(ctrl)
|
|
lobby := mocks.NewMockLobbyClient(ctrl)
|
|
|
|
engine.EXPECT().
|
|
Turn(gomock.Any(), gomock.Any()).
|
|
Times(2).
|
|
Return(ports.StateResponse{Turn: 1, Players: []ports.PlayerState{
|
|
{RaceName: "Aelinari", EnginePlayerUUID: "uuid-1", Planets: 1, Population: 10},
|
|
{RaceName: "Drazi", EnginePlayerUUID: "uuid-2", Planets: 1, Population: 10},
|
|
}}, nil)
|
|
lobbyEvents.EXPECT().PublishSnapshotUpdate(gomock.Any(), gomock.Any()).Times(2).Return(nil)
|
|
lobby.EXPECT().GetGameSummary(gomock.Any(), gomock.Any()).Times(2).
|
|
Return(ports.GameSummary{GameID: "g", GameName: "Game", Status: "running"}, nil)
|
|
notifications.EXPECT().Publish(gomock.Any(), gomock.Any()).Times(2).Return(nil)
|
|
|
|
turn, err := turngeneration.NewService(turngeneration.Dependencies{
|
|
RuntimeRecords: store,
|
|
PlayerMappings: mappings,
|
|
OperationLogs: stubLogs{},
|
|
Engine: engine,
|
|
LobbyEvents: lobbyEvents,
|
|
Notifications: notifications,
|
|
Lobby: lobby,
|
|
Scheduler: scheduler.New(),
|
|
Telemetry: telem,
|
|
Clock: func() time.Time { return now },
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
worker, err := schedulerticker.NewWorker(schedulerticker.Dependencies{
|
|
RuntimeRecords: store,
|
|
TurnGeneration: turn,
|
|
Telemetry: telem,
|
|
Interval: time.Second,
|
|
Clock: func() time.Time { return now },
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
worker.Tick(context.Background())
|
|
worker.Wait()
|
|
|
|
// Both games should have advanced from running → running with
|
|
// current_turn=1.
|
|
for _, gameID := range []string{"game-a", "game-b"} {
|
|
record, err := store.Get(context.Background(), gameID)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, runtime.StatusRunning, record.Status, "game %s", gameID)
|
|
assert.Equal(t, 1, record.CurrentTurn, "game %s", gameID)
|
|
}
|
|
}
|
|
|
|
func TestTickDeduplicatesInflightGame(t *testing.T) {
|
|
ctrl := gomock.NewController(t)
|
|
telem := newTelemetry(t)
|
|
store := newFakeRuntimeRecordsBackend()
|
|
mappings := &stubMappings{}
|
|
|
|
now := time.Date(2026, time.April, 30, 12, 0, 0, 0, time.UTC)
|
|
due := now.Add(-5 * time.Minute)
|
|
seedRunningRecord(t, store, mappings, "game-a", due)
|
|
|
|
engine := mocks.NewMockEngineClient(ctrl)
|
|
lobbyEvents := mocks.NewMockLobbyEventsPublisher(ctrl)
|
|
notifications := mocks.NewMockNotificationIntentPublisher(ctrl)
|
|
lobby := mocks.NewMockLobbyClient(ctrl)
|
|
|
|
releaseEngine := make(chan struct{})
|
|
engine.EXPECT().
|
|
Turn(gomock.Any(), gomock.Any()).
|
|
Times(1).
|
|
DoAndReturn(func(ctx context.Context, _ string) (ports.StateResponse, error) {
|
|
select {
|
|
case <-releaseEngine:
|
|
case <-ctx.Done():
|
|
}
|
|
return ports.StateResponse{Turn: 1, Players: []ports.PlayerState{
|
|
{RaceName: "Aelinari", EnginePlayerUUID: "uuid-1", Planets: 1, Population: 10},
|
|
{RaceName: "Drazi", EnginePlayerUUID: "uuid-2", Planets: 1, Population: 10},
|
|
}}, nil
|
|
})
|
|
lobbyEvents.EXPECT().PublishSnapshotUpdate(gomock.Any(), gomock.Any()).Times(1).Return(nil)
|
|
lobby.EXPECT().GetGameSummary(gomock.Any(), gomock.Any()).Times(1).
|
|
Return(ports.GameSummary{GameID: "game-a", GameName: "Game A", Status: "running"}, nil)
|
|
notifications.EXPECT().Publish(gomock.Any(), gomock.Any()).Times(1).Return(nil)
|
|
|
|
turn, err := turngeneration.NewService(turngeneration.Dependencies{
|
|
RuntimeRecords: store,
|
|
PlayerMappings: mappings,
|
|
OperationLogs: stubLogs{},
|
|
Engine: engine,
|
|
LobbyEvents: lobbyEvents,
|
|
Notifications: notifications,
|
|
Lobby: lobby,
|
|
Scheduler: scheduler.New(),
|
|
Telemetry: telem,
|
|
Clock: func() time.Time { return now },
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
worker, err := schedulerticker.NewWorker(schedulerticker.Dependencies{
|
|
RuntimeRecords: store,
|
|
TurnGeneration: turn,
|
|
Telemetry: telem,
|
|
Interval: time.Second,
|
|
Clock: func() time.Time { return now },
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
worker.Tick(context.Background())
|
|
// Reset the runtime row to running so the second Tick would normally
|
|
// re-dispatch; the in-flight set must still skip it.
|
|
store.mu.Lock()
|
|
rec := store.stored["game-a"]
|
|
rec.Status = runtime.StatusRunning
|
|
rec.NextGenerationAt = &due
|
|
store.stored["game-a"] = rec
|
|
store.mu.Unlock()
|
|
|
|
worker.Tick(context.Background())
|
|
|
|
close(releaseEngine)
|
|
worker.Wait()
|
|
|
|
// Only one engine call must have happened despite two ticks.
|
|
assert.GreaterOrEqual(t, store.listCalls.Load(), int32(2), "ListDueRunning observed both ticks")
|
|
}
|
|
|
|
func TestTickAbsorbsListError(t *testing.T) {
|
|
ctrl := gomock.NewController(t)
|
|
telem := newTelemetry(t)
|
|
store := newFakeRuntimeRecordsBackend()
|
|
store.listErr = errors.New("postgres timeout")
|
|
|
|
engine := mocks.NewMockEngineClient(ctrl)
|
|
lobbyEvents := mocks.NewMockLobbyEventsPublisher(ctrl)
|
|
notifications := mocks.NewMockNotificationIntentPublisher(ctrl)
|
|
lobby := mocks.NewMockLobbyClient(ctrl)
|
|
|
|
turn, err := turngeneration.NewService(turngeneration.Dependencies{
|
|
RuntimeRecords: store,
|
|
PlayerMappings: &stubMappings{},
|
|
OperationLogs: stubLogs{},
|
|
Engine: engine,
|
|
LobbyEvents: lobbyEvents,
|
|
Notifications: notifications,
|
|
Lobby: lobby,
|
|
Scheduler: scheduler.New(),
|
|
Telemetry: telem,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
worker, err := schedulerticker.NewWorker(schedulerticker.Dependencies{
|
|
RuntimeRecords: store,
|
|
TurnGeneration: turn,
|
|
Telemetry: telem,
|
|
Interval: time.Second,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
worker.Tick(context.Background())
|
|
worker.Wait()
|
|
}
|
|
|
|
func TestTickEmptyDueListIsNoOp(t *testing.T) {
|
|
ctrl := gomock.NewController(t)
|
|
telem := newTelemetry(t)
|
|
store := newFakeRuntimeRecordsBackend()
|
|
|
|
engine := mocks.NewMockEngineClient(ctrl)
|
|
lobbyEvents := mocks.NewMockLobbyEventsPublisher(ctrl)
|
|
notifications := mocks.NewMockNotificationIntentPublisher(ctrl)
|
|
lobby := mocks.NewMockLobbyClient(ctrl)
|
|
|
|
turn, err := turngeneration.NewService(turngeneration.Dependencies{
|
|
RuntimeRecords: store,
|
|
PlayerMappings: &stubMappings{},
|
|
OperationLogs: stubLogs{},
|
|
Engine: engine,
|
|
LobbyEvents: lobbyEvents,
|
|
Notifications: notifications,
|
|
Lobby: lobby,
|
|
Scheduler: scheduler.New(),
|
|
Telemetry: telem,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
worker, err := schedulerticker.NewWorker(schedulerticker.Dependencies{
|
|
RuntimeRecords: store,
|
|
TurnGeneration: turn,
|
|
Telemetry: telem,
|
|
Interval: time.Second,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
worker.Tick(context.Background())
|
|
worker.Wait()
|
|
}
|
|
|
|
func TestRunStopsOnContextCancellation(t *testing.T) {
|
|
ctrl := gomock.NewController(t)
|
|
telem := newTelemetry(t)
|
|
store := newFakeRuntimeRecordsBackend()
|
|
|
|
engine := mocks.NewMockEngineClient(ctrl)
|
|
lobbyEvents := mocks.NewMockLobbyEventsPublisher(ctrl)
|
|
notifications := mocks.NewMockNotificationIntentPublisher(ctrl)
|
|
lobby := mocks.NewMockLobbyClient(ctrl)
|
|
|
|
turn, err := turngeneration.NewService(turngeneration.Dependencies{
|
|
RuntimeRecords: store,
|
|
PlayerMappings: &stubMappings{},
|
|
OperationLogs: stubLogs{},
|
|
Engine: engine,
|
|
LobbyEvents: lobbyEvents,
|
|
Notifications: notifications,
|
|
Lobby: lobby,
|
|
Scheduler: scheduler.New(),
|
|
Telemetry: telem,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
worker, err := schedulerticker.NewWorker(schedulerticker.Dependencies{
|
|
RuntimeRecords: store,
|
|
TurnGeneration: turn,
|
|
Telemetry: telem,
|
|
Interval: 10 * time.Millisecond,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
done := make(chan error, 1)
|
|
go func() { done <- worker.Run(ctx) }()
|
|
cancel()
|
|
select {
|
|
case err := <-done:
|
|
assert.ErrorIs(t, err, context.Canceled)
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("worker did not exit on context cancellation")
|
|
}
|
|
}
|
|
|
|
// buildTurnService is a thin helper for the missing-deps test cases —
|
|
// it does not exercise the engine because the deps test never reaches
|
|
// the work path.
|
|
func buildTurnService(t *testing.T, ctrl *gomock.Controller, store *fakeRuntimeRecordsBackend, mappings *stubMappings, telem *telemetry.Runtime) *turngeneration.Service {
|
|
t.Helper()
|
|
turn, err := turngeneration.NewService(turngeneration.Dependencies{
|
|
RuntimeRecords: store,
|
|
PlayerMappings: mappings,
|
|
OperationLogs: stubLogs{},
|
|
Engine: mocks.NewMockEngineClient(ctrl),
|
|
LobbyEvents: mocks.NewMockLobbyEventsPublisher(ctrl),
|
|
Notifications: mocks.NewMockNotificationIntentPublisher(ctrl),
|
|
Lobby: mocks.NewMockLobbyClient(ctrl),
|
|
Scheduler: scheduler.New(),
|
|
Telemetry: telem,
|
|
})
|
|
require.NoError(t, err)
|
|
return turn
|
|
}
|