Ilia Denisov
585 lines
18 KiB
Go
585 lines
18 KiB
Go
package restartruntime_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"galaxy/notificationintent"
|
|
"galaxy/rtmanager/internal/adapters/docker/mocks"
|
|
"galaxy/rtmanager/internal/config"
|
|
"galaxy/rtmanager/internal/domain/operation"
|
|
"galaxy/rtmanager/internal/domain/runtime"
|
|
"galaxy/rtmanager/internal/ports"
|
|
"galaxy/rtmanager/internal/service/restartruntime"
|
|
"galaxy/rtmanager/internal/service/startruntime"
|
|
"galaxy/rtmanager/internal/service/stopruntime"
|
|
"galaxy/rtmanager/internal/telemetry"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"go.uber.org/mock/gomock"
|
|
)
|
|
|
|
// --- shared fake doubles ----------------------------------------------
|
|
|
|
type fakeRuntimeRecords struct {
|
|
mu sync.Mutex
|
|
|
|
stored map[string]runtime.RuntimeRecord
|
|
getErr error
|
|
upsertErr error
|
|
updateStatusErr error
|
|
|
|
upserts []runtime.RuntimeRecord
|
|
updates []ports.UpdateStatusInput
|
|
}
|
|
|
|
func newFakeRuntimeRecords() *fakeRuntimeRecords {
|
|
return &fakeRuntimeRecords{stored: map[string]runtime.RuntimeRecord{}}
|
|
}
|
|
|
|
func (s *fakeRuntimeRecords) Get(_ context.Context, gameID string) (runtime.RuntimeRecord, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if s.getErr != nil {
|
|
return runtime.RuntimeRecord{}, s.getErr
|
|
}
|
|
record, ok := s.stored[gameID]
|
|
if !ok {
|
|
return runtime.RuntimeRecord{}, runtime.ErrNotFound
|
|
}
|
|
return record, nil
|
|
}
|
|
|
|
func (s *fakeRuntimeRecords) Upsert(_ context.Context, record runtime.RuntimeRecord) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if s.upsertErr != nil {
|
|
return s.upsertErr
|
|
}
|
|
s.upserts = append(s.upserts, record)
|
|
s.stored[record.GameID] = record
|
|
return nil
|
|
}
|
|
|
|
func (s *fakeRuntimeRecords) UpdateStatus(_ context.Context, input ports.UpdateStatusInput) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.updates = append(s.updates, input)
|
|
if s.updateStatusErr != nil {
|
|
return s.updateStatusErr
|
|
}
|
|
record, ok := s.stored[input.GameID]
|
|
if !ok {
|
|
return runtime.ErrNotFound
|
|
}
|
|
if record.Status != input.ExpectedFrom {
|
|
return runtime.ErrConflict
|
|
}
|
|
if input.ExpectedContainerID != "" && record.CurrentContainerID != input.ExpectedContainerID {
|
|
return runtime.ErrConflict
|
|
}
|
|
record.Status = input.To
|
|
record.LastOpAt = input.Now
|
|
switch input.To {
|
|
case runtime.StatusStopped:
|
|
stoppedAt := input.Now
|
|
record.StoppedAt = &stoppedAt
|
|
case runtime.StatusRemoved:
|
|
removedAt := input.Now
|
|
record.RemovedAt = &removedAt
|
|
record.CurrentContainerID = ""
|
|
}
|
|
s.stored[input.GameID] = record
|
|
return nil
|
|
}
|
|
|
|
func (s *fakeRuntimeRecords) ListByStatus(_ context.Context, _ runtime.Status) ([]runtime.RuntimeRecord, error) {
|
|
return nil, errors.New("not used in restart tests")
|
|
}
|
|
|
|
func (s *fakeRuntimeRecords) List(_ context.Context) ([]runtime.RuntimeRecord, error) {
|
|
return nil, errors.New("not used in restart tests")
|
|
}
|
|
|
|
type fakeOperationLogs struct {
|
|
mu sync.Mutex
|
|
|
|
appendErr error
|
|
appends []operation.OperationEntry
|
|
}
|
|
|
|
func (s *fakeOperationLogs) Append(_ context.Context, entry operation.OperationEntry) (int64, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if s.appendErr != nil {
|
|
return 0, s.appendErr
|
|
}
|
|
s.appends = append(s.appends, entry)
|
|
return int64(len(s.appends)), nil
|
|
}
|
|
|
|
func (s *fakeOperationLogs) ListByGame(_ context.Context, _ string, _ int) ([]operation.OperationEntry, error) {
|
|
return nil, errors.New("not used in restart tests")
|
|
}
|
|
|
|
func (s *fakeOperationLogs) byKind(kind operation.OpKind) []operation.OperationEntry {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
out := []operation.OperationEntry{}
|
|
for _, entry := range s.appends {
|
|
if entry.OpKind == kind {
|
|
out = append(out, entry)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
type fakeLeases struct {
|
|
mu sync.Mutex
|
|
|
|
acquired bool
|
|
acquireErr error
|
|
releaseErr error
|
|
|
|
acquires []string
|
|
releases []string
|
|
}
|
|
|
|
func (l *fakeLeases) TryAcquire(_ context.Context, _, token string, _ time.Duration) (bool, error) {
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
l.acquires = append(l.acquires, token)
|
|
if l.acquireErr != nil {
|
|
return false, l.acquireErr
|
|
}
|
|
return l.acquired, nil
|
|
}
|
|
|
|
func (l *fakeLeases) Release(_ context.Context, _, token string) error {
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
l.releases = append(l.releases, token)
|
|
return l.releaseErr
|
|
}
|
|
|
|
type fakeHealthEvents struct {
|
|
mu sync.Mutex
|
|
|
|
publishErr error
|
|
envelopes []ports.HealthEventEnvelope
|
|
}
|
|
|
|
func (h *fakeHealthEvents) Publish(_ context.Context, envelope ports.HealthEventEnvelope) error {
|
|
h.mu.Lock()
|
|
defer h.mu.Unlock()
|
|
if h.publishErr != nil {
|
|
return h.publishErr
|
|
}
|
|
h.envelopes = append(h.envelopes, envelope)
|
|
return nil
|
|
}
|
|
|
|
type fakeNotifications struct {
|
|
mu sync.Mutex
|
|
|
|
publishErr error
|
|
intents []notificationintent.Intent
|
|
}
|
|
|
|
func (n *fakeNotifications) Publish(_ context.Context, intent notificationintent.Intent) error {
|
|
n.mu.Lock()
|
|
defer n.mu.Unlock()
|
|
if n.publishErr != nil {
|
|
return n.publishErr
|
|
}
|
|
n.intents = append(n.intents, intent)
|
|
return nil
|
|
}
|
|
|
|
type fakeLobby struct {
|
|
record ports.LobbyGameRecord
|
|
err error
|
|
}
|
|
|
|
func (l *fakeLobby) GetGame(_ context.Context, _ string) (ports.LobbyGameRecord, error) {
|
|
if l.err != nil {
|
|
return ports.LobbyGameRecord{}, l.err
|
|
}
|
|
return l.record, nil
|
|
}
|
|
|
|
// --- harness ----------------------------------------------------------
|
|
|
|
type harness struct {
|
|
records *fakeRuntimeRecords
|
|
operationLogs *fakeOperationLogs
|
|
docker *mocks.MockDockerClient
|
|
leases *fakeLeases
|
|
healthEvents *fakeHealthEvents
|
|
notifications *fakeNotifications
|
|
lobby *fakeLobby
|
|
telemetry *telemetry.Runtime
|
|
|
|
now time.Time
|
|
stateDir string
|
|
|
|
startService *startruntime.Service
|
|
stopService *stopruntime.Service
|
|
}
|
|
|
|
func newHarness(t *testing.T) *harness {
|
|
t.Helper()
|
|
ctrl := gomock.NewController(t)
|
|
t.Cleanup(ctrl.Finish)
|
|
|
|
telemetryRuntime, err := telemetry.NewWithProviders(nil, nil)
|
|
require.NoError(t, err)
|
|
|
|
h := &harness{
|
|
records: newFakeRuntimeRecords(),
|
|
operationLogs: &fakeOperationLogs{},
|
|
docker: mocks.NewMockDockerClient(ctrl),
|
|
leases: &fakeLeases{acquired: true},
|
|
healthEvents: &fakeHealthEvents{},
|
|
notifications: &fakeNotifications{},
|
|
lobby: &fakeLobby{},
|
|
telemetry: telemetryRuntime,
|
|
now: time.Date(2026, 4, 27, 12, 0, 0, 0, time.UTC),
|
|
stateDir: "/var/lib/galaxy/games/game-1",
|
|
}
|
|
|
|
containerCfg := config.ContainerConfig{
|
|
DefaultCPUQuota: 1.0,
|
|
DefaultMemory: "512m",
|
|
DefaultPIDsLimit: 512,
|
|
StopTimeout: 30 * time.Second,
|
|
Retention: 30 * 24 * time.Hour,
|
|
EngineStateMountPath: "/var/lib/galaxy-game",
|
|
EngineStateEnvName: "GAME_STATE_PATH",
|
|
GameStateDirMode: 0o750,
|
|
GameStateRoot: "/var/lib/galaxy/games",
|
|
}
|
|
dockerCfg := config.DockerConfig{
|
|
Host: "unix:///var/run/docker.sock",
|
|
Network: "galaxy-net",
|
|
LogDriver: "json-file",
|
|
PullPolicy: config.ImagePullPolicyIfMissing,
|
|
}
|
|
coordinationCfg := config.CoordinationConfig{GameLeaseTTL: time.Minute}
|
|
|
|
startService, err := startruntime.NewService(startruntime.Dependencies{
|
|
RuntimeRecords: h.records,
|
|
OperationLogs: h.operationLogs,
|
|
Docker: h.docker,
|
|
Leases: h.leases,
|
|
HealthEvents: h.healthEvents,
|
|
Notifications: h.notifications,
|
|
Lobby: h.lobby,
|
|
Container: containerCfg,
|
|
DockerCfg: dockerCfg,
|
|
Coordination: coordinationCfg,
|
|
Telemetry: h.telemetry,
|
|
Clock: func() time.Time { return h.now },
|
|
NewToken: func() string { return "inner-start-token" },
|
|
PrepareStateDir: func(_ string) (string, error) { return h.stateDir, nil },
|
|
})
|
|
require.NoError(t, err)
|
|
h.startService = startService
|
|
|
|
stopService, err := stopruntime.NewService(stopruntime.Dependencies{
|
|
RuntimeRecords: h.records,
|
|
OperationLogs: h.operationLogs,
|
|
Docker: h.docker,
|
|
Leases: h.leases,
|
|
HealthEvents: h.healthEvents,
|
|
Container: containerCfg,
|
|
Coordination: coordinationCfg,
|
|
Telemetry: h.telemetry,
|
|
Clock: func() time.Time { return h.now },
|
|
NewToken: func() string { return "inner-stop-token" },
|
|
})
|
|
require.NoError(t, err)
|
|
h.stopService = stopService
|
|
|
|
return h
|
|
}
|
|
|
|
func (h *harness) build(t *testing.T, tokens ...string) *restartruntime.Service {
|
|
t.Helper()
|
|
tokenIdx := 0
|
|
tokenGen := func() string {
|
|
if tokenIdx >= len(tokens) {
|
|
return "outer-fallback"
|
|
}
|
|
t := tokens[tokenIdx]
|
|
tokenIdx++
|
|
return t
|
|
}
|
|
service, err := restartruntime.NewService(restartruntime.Dependencies{
|
|
RuntimeRecords: h.records,
|
|
OperationLogs: h.operationLogs,
|
|
Docker: h.docker,
|
|
Leases: h.leases,
|
|
StopService: h.stopService,
|
|
StartService: h.startService,
|
|
Coordination: config.CoordinationConfig{GameLeaseTTL: time.Minute},
|
|
Telemetry: h.telemetry,
|
|
Clock: func() time.Time { return h.now },
|
|
NewToken: tokenGen,
|
|
})
|
|
require.NoError(t, err)
|
|
return service
|
|
}
|
|
|
|
const imageRef = "registry.example.com/galaxy/game:1.4.7"
|
|
|
|
func runningRecord(now time.Time) runtime.RuntimeRecord {
|
|
startedAt := now.Add(-time.Hour)
|
|
return runtime.RuntimeRecord{
|
|
GameID: "game-1",
|
|
Status: runtime.StatusRunning,
|
|
CurrentContainerID: "ctr-old",
|
|
CurrentImageRef: imageRef,
|
|
EngineEndpoint: "http://galaxy-game-game-1:8080",
|
|
StatePath: "/var/lib/galaxy/games/game-1",
|
|
DockerNetwork: "galaxy-net",
|
|
StartedAt: &startedAt,
|
|
LastOpAt: startedAt,
|
|
CreatedAt: startedAt,
|
|
}
|
|
}
|
|
|
|
func basicInput() restartruntime.Input {
|
|
return restartruntime.Input{
|
|
GameID: "game-1",
|
|
OpSource: operation.OpSourceGMRest,
|
|
SourceRef: "rest-req-42",
|
|
}
|
|
}
|
|
|
|
func sampleRunResult(now time.Time) ports.RunResult {
|
|
return ports.RunResult{
|
|
ContainerID: "ctr-new",
|
|
EngineEndpoint: "http://galaxy-game-game-1:8080",
|
|
StartedAt: now,
|
|
}
|
|
}
|
|
|
|
func expectInnerStart(h *harness) {
|
|
h.docker.EXPECT().EnsureNetwork(gomock.Any(), "galaxy-net").Return(nil)
|
|
h.docker.EXPECT().PullImage(gomock.Any(), imageRef, gomock.Any()).Return(nil)
|
|
h.docker.EXPECT().InspectImage(gomock.Any(), imageRef).Return(ports.ImageInspect{Ref: imageRef}, nil)
|
|
h.docker.EXPECT().Run(gomock.Any(), gomock.Any()).Return(sampleRunResult(h.now), nil)
|
|
}
|
|
|
|
// --- happy path -------------------------------------------------------
|
|
|
|
func TestHandleRestartFromRunning(t *testing.T) {
|
|
h := newHarness(t)
|
|
h.records.stored["game-1"] = runningRecord(h.now)
|
|
|
|
h.docker.EXPECT().Stop(gomock.Any(), "ctr-old", 30*time.Second).Return(nil)
|
|
h.docker.EXPECT().Remove(gomock.Any(), "ctr-old").Return(nil)
|
|
expectInnerStart(h)
|
|
|
|
service := h.build(t, "outer-token")
|
|
result, err := service.Handle(context.Background(), basicInput())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeSuccess, result.Outcome)
|
|
assert.Empty(t, result.ErrorCode)
|
|
assert.Equal(t, "ctr-new", result.Record.CurrentContainerID)
|
|
assert.Equal(t, imageRef, result.Record.CurrentImageRef)
|
|
assert.Equal(t, runtime.StatusRunning, result.Record.Status)
|
|
|
|
stops := h.operationLogs.byKind(operation.OpKindStop)
|
|
starts := h.operationLogs.byKind(operation.OpKindStart)
|
|
restarts := h.operationLogs.byKind(operation.OpKindRestart)
|
|
require.Len(t, stops, 1, "inner stop appended its own entry")
|
|
require.Len(t, starts, 1, "inner start appended its own entry")
|
|
require.Len(t, restarts, 1, "outer restart appended one summary entry")
|
|
|
|
assert.Equal(t, "rest-req-42", stops[0].SourceRef, "correlation id propagated to inner stop")
|
|
assert.Equal(t, "rest-req-42", starts[0].SourceRef, "correlation id propagated to inner start")
|
|
assert.Equal(t, "rest-req-42", restarts[0].SourceRef, "correlation id stored on outer restart")
|
|
assert.Equal(t, "ctr-new", restarts[0].ContainerID)
|
|
assert.Equal(t, imageRef, restarts[0].ImageRef)
|
|
|
|
assert.Equal(t, []string{"outer-token"}, h.leases.acquires)
|
|
assert.Equal(t, []string{"outer-token"}, h.leases.releases)
|
|
}
|
|
|
|
func TestHandleRestartFromStopped(t *testing.T) {
|
|
h := newHarness(t)
|
|
stoppedRecord := runningRecord(h.now)
|
|
stoppedRecord.Status = runtime.StatusStopped
|
|
stoppedAt := h.now.Add(-30 * time.Minute)
|
|
stoppedRecord.StoppedAt = &stoppedAt
|
|
h.records.stored["game-1"] = stoppedRecord
|
|
|
|
// No docker.Stop because inner stop short-circuits via replay no-op.
|
|
h.docker.EXPECT().Remove(gomock.Any(), "ctr-old").Return(nil)
|
|
expectInnerStart(h)
|
|
|
|
service := h.build(t, "outer-token")
|
|
result, err := service.Handle(context.Background(), basicInput())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeSuccess, result.Outcome)
|
|
assert.Equal(t, "ctr-new", result.Record.CurrentContainerID)
|
|
}
|
|
|
|
// --- correlation id fallback -----------------------------------------
|
|
|
|
func TestHandleGeneratesCorrelationWhenSourceRefEmpty(t *testing.T) {
|
|
h := newHarness(t)
|
|
h.records.stored["game-1"] = runningRecord(h.now)
|
|
|
|
h.docker.EXPECT().Stop(gomock.Any(), "ctr-old", 30*time.Second).Return(nil)
|
|
h.docker.EXPECT().Remove(gomock.Any(), "ctr-old").Return(nil)
|
|
expectInnerStart(h)
|
|
|
|
input := basicInput()
|
|
input.SourceRef = ""
|
|
|
|
// First newToken call yields the lease token, second yields the
|
|
// correlation id fallback.
|
|
service := h.build(t, "outer-token", "correlation-fallback")
|
|
result, err := service.Handle(context.Background(), input)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeSuccess, result.Outcome)
|
|
|
|
stops := h.operationLogs.byKind(operation.OpKindStop)
|
|
starts := h.operationLogs.byKind(operation.OpKindStart)
|
|
restarts := h.operationLogs.byKind(operation.OpKindRestart)
|
|
require.Len(t, stops, 1)
|
|
require.Len(t, starts, 1)
|
|
require.Len(t, restarts, 1)
|
|
assert.Equal(t, "correlation-fallback", stops[0].SourceRef)
|
|
assert.Equal(t, "correlation-fallback", starts[0].SourceRef)
|
|
assert.Equal(t, "correlation-fallback", restarts[0].SourceRef)
|
|
}
|
|
|
|
// --- failure paths ---------------------------------------------------
|
|
|
|
func TestHandleNotFoundForMissingRecord(t *testing.T) {
|
|
h := newHarness(t)
|
|
service := h.build(t, "outer-token")
|
|
|
|
result, err := service.Handle(context.Background(), basicInput())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeFailure, result.Outcome)
|
|
assert.Equal(t, startruntime.ErrorCodeNotFound, result.ErrorCode)
|
|
assert.Empty(t, h.operationLogs.byKind(operation.OpKindStop))
|
|
assert.Empty(t, h.operationLogs.byKind(operation.OpKindStart))
|
|
require.Len(t, h.operationLogs.byKind(operation.OpKindRestart), 1)
|
|
}
|
|
|
|
func TestHandleConflictForRemovedRecord(t *testing.T) {
|
|
h := newHarness(t)
|
|
removed := runningRecord(h.now)
|
|
removed.Status = runtime.StatusRemoved
|
|
removed.CurrentContainerID = ""
|
|
removedAt := h.now.Add(-time.Hour)
|
|
removed.RemovedAt = &removedAt
|
|
h.records.stored["game-1"] = removed
|
|
|
|
service := h.build(t, "outer-token")
|
|
result, err := service.Handle(context.Background(), basicInput())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeFailure, result.Outcome)
|
|
assert.Equal(t, startruntime.ErrorCodeConflict, result.ErrorCode)
|
|
}
|
|
|
|
func TestHandleConflictWhenLeaseBusy(t *testing.T) {
|
|
h := newHarness(t)
|
|
h.leases.acquired = false
|
|
|
|
service := h.build(t, "outer-token")
|
|
result, err := service.Handle(context.Background(), basicInput())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeFailure, result.Outcome)
|
|
assert.Equal(t, startruntime.ErrorCodeConflict, result.ErrorCode)
|
|
assert.Empty(t, h.leases.releases, "release must not run when acquire returned false")
|
|
}
|
|
|
|
func TestHandlePropagatesInnerStopFailure(t *testing.T) {
|
|
h := newHarness(t)
|
|
h.records.stored["game-1"] = runningRecord(h.now)
|
|
|
|
h.docker.EXPECT().Stop(gomock.Any(), "ctr-old", 30*time.Second).Return(errors.New("daemon unreachable"))
|
|
|
|
service := h.build(t, "outer-token")
|
|
result, err := service.Handle(context.Background(), basicInput())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeFailure, result.Outcome)
|
|
assert.Equal(t, startruntime.ErrorCodeServiceUnavailable, result.ErrorCode)
|
|
assert.Contains(t, result.ErrorMessage, "inner stop failed")
|
|
}
|
|
|
|
func TestHandleServiceUnavailableOnDockerRemoveFailure(t *testing.T) {
|
|
h := newHarness(t)
|
|
h.records.stored["game-1"] = runningRecord(h.now)
|
|
|
|
h.docker.EXPECT().Stop(gomock.Any(), "ctr-old", 30*time.Second).Return(nil)
|
|
h.docker.EXPECT().Remove(gomock.Any(), "ctr-old").Return(errors.New("disk i/o"))
|
|
|
|
service := h.build(t, "outer-token")
|
|
result, err := service.Handle(context.Background(), basicInput())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeFailure, result.Outcome)
|
|
assert.Equal(t, startruntime.ErrorCodeServiceUnavailable, result.ErrorCode)
|
|
assert.Contains(t, result.ErrorMessage, "docker remove")
|
|
// inner stop did succeed and write its log entry; outer restart records failure.
|
|
require.Len(t, h.operationLogs.byKind(operation.OpKindStop), 1)
|
|
require.Len(t, h.operationLogs.byKind(operation.OpKindRestart), 1)
|
|
}
|
|
|
|
func TestHandlePropagatesInnerStartFailure(t *testing.T) {
|
|
h := newHarness(t)
|
|
h.records.stored["game-1"] = runningRecord(h.now)
|
|
|
|
h.docker.EXPECT().Stop(gomock.Any(), "ctr-old", 30*time.Second).Return(nil)
|
|
h.docker.EXPECT().Remove(gomock.Any(), "ctr-old").Return(nil)
|
|
h.docker.EXPECT().EnsureNetwork(gomock.Any(), "galaxy-net").Return(nil)
|
|
h.docker.EXPECT().PullImage(gomock.Any(), imageRef, gomock.Any()).Return(errors.New("manifest unknown"))
|
|
|
|
service := h.build(t, "outer-token")
|
|
result, err := service.Handle(context.Background(), basicInput())
|
|
require.NoError(t, err)
|
|
assert.Equal(t, operation.OutcomeFailure, result.Outcome)
|
|
assert.Equal(t, startruntime.ErrorCodeImagePullFailed, result.ErrorCode)
|
|
assert.Contains(t, result.ErrorMessage, "inner start failed")
|
|
}
|
|
|
|
// --- input validation ------------------------------------------------
|
|
|
|
func TestHandleRejectsInvalidInput(t *testing.T) {
|
|
h := newHarness(t)
|
|
service := h.build(t, "outer-token")
|
|
|
|
cases := []restartruntime.Input{
|
|
{GameID: "", OpSource: operation.OpSourceGMRest},
|
|
{GameID: "g", OpSource: operation.OpSource("bogus")},
|
|
}
|
|
for _, input := range cases {
|
|
result, err := service.Handle(context.Background(), input)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, startruntime.ErrorCodeInvalidRequest, result.ErrorCode)
|
|
}
|
|
}
|
|
|
|
// --- constructor -----------------------------------------------------
|
|
|
|
func TestNewServiceRejectsMissingDependencies(t *testing.T) {
|
|
h := newHarness(t)
|
|
deps := restartruntime.Dependencies{
|
|
Coordination: config.CoordinationConfig{GameLeaseTTL: time.Minute},
|
|
Telemetry: h.telemetry,
|
|
}
|
|
_, err := restartruntime.NewService(deps)
|
|
require.Error(t, err)
|
|
}
|