Ilia Denisov
601970b028
Three-stage refactor of the game-engine plumbing (game logic untouched): Stage 1 — lock-free persistence + admin serialisation. Remove the file lock from repo/fs (the .lock file, the Read/Write-vs-*Safe duality and the dead ReadSafe polling) and replace the two-step rename with a single atomic rename so concurrent reads are torn-free without a lock. Serialise the state-mutating admin writers (init/turn/banish) with one shared router LimitMiddleware, rewritten to block on the request context instead of a racy shared 100ms timer. Stage 2 — remove the obsolete immediate-command path end to end. Players submit through PUT /api/v1/order; the legacy PUT /api/v1/command path is deleted across game (route, handler, 24 command factories, Ctrl), backend (Commands handler/route, engineclient.ExecuteCommands), gateway (dispatch + executeUserGamesCommand + routing entry), the FlatBuffers/model contract (UserGamesCommand[Response]) and transcoder, plus every affected OpenAPI/README/FUNCTIONAL/ARCHITECTURE doc. The integration proxy test is converted to the order path. Stage 3 — flatten the REST->engine wrapper. Replace the executor adapter, the controller package functions and RepoController with one concrete controller.Service; drop the single-implementation Repo and Storage interfaces (repo.Repo / fs.FS are now concrete). Handlers depend on a thin handler.Engine seam and own the domain->REST projection; storage is resolved once at startup instead of per request. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
77 lines
2.6 KiB
Go
77 lines
2.6 KiB
Go
package controller_test
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"galaxy/model/order"
|
|
|
|
"galaxy/util"
|
|
|
|
"galaxy/game/internal/controller"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// TestServiceOrderStoredThenAppliedAtTurn is the end-to-end regression for the
|
|
// order lifecycle against a real Service backed by a temporary storage
|
|
// directory: an order submitted through ValidateOrder is persisted (FetchOrder
|
|
// returns it before the turn), applied when the turn is produced (GenerateTurn
|
|
// advances the turn), and its per-command verdict survives turn production
|
|
// (FetchOrder still returns it with cmdApplied set). It guards the wiring the
|
|
// Stage 3 collapse reworked — Service methods threading the concrete repo
|
|
// through validate → store → produce → read-back.
|
|
func TestServiceOrderStoredThenAppliedAtTurn(t *testing.T) {
|
|
root, cleanup := util.CreateWorkDir(t)
|
|
defer cleanup()
|
|
|
|
svc, err := controller.NewService(root)
|
|
require.NoError(t, err)
|
|
|
|
races := make([]string, 10)
|
|
for i := range races {
|
|
races[i] = fmt.Sprintf("race_%02d", i)
|
|
}
|
|
if _, err := svc.GenerateGame(uuid.New(), races); err != nil {
|
|
t.Fatalf("init game: %v", err)
|
|
}
|
|
|
|
vote := &order.CommandRaceVote{
|
|
CommandMeta: order.CommandMeta{CmdID: uuid.NewString(), CmdType: order.CommandTypeRaceVote},
|
|
Acceptor: races[1],
|
|
}
|
|
stored, err := svc.ValidateOrder(races[0], vote)
|
|
require.NoError(t, err)
|
|
require.Len(t, stored.Commands, 1)
|
|
|
|
// The order is persisted and retrievable for the current turn (0)
|
|
// before the turn is produced.
|
|
got, ok, err := svc.FetchOrder(races[0], 0)
|
|
require.NoError(t, err)
|
|
require.True(t, ok, "submitted order must be retrievable before the turn")
|
|
require.Len(t, got.Commands, 1)
|
|
|
|
// Producing the turn applies stored orders and advances the turn.
|
|
state, err := svc.GenerateTurn()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, uint(1), state.Turn, "turn must advance after production")
|
|
|
|
// The turn-0 order still carries its per-command verdict, recorded by
|
|
// turn production.
|
|
applied, ok, err := svc.FetchOrder(races[0], 0)
|
|
require.NoError(t, err)
|
|
require.True(t, ok)
|
|
require.Len(t, applied.Commands, 1)
|
|
v, ok := order.AsCommand[*order.CommandRaceVote](applied.Commands[0])
|
|
require.True(t, ok, "stored command must round-trip to its concrete type")
|
|
require.NotNil(t, v.CmdApplied, "turn production must record cmdApplied")
|
|
assert.True(t, *v.CmdApplied, "a valid vote must apply at turn production")
|
|
|
|
// Orders are per-turn: the freshly produced turn carries no order yet.
|
|
_, ok, err = svc.FetchOrder(races[0], 1)
|
|
require.NoError(t, err)
|
|
assert.False(t, ok, "the freshly produced turn carries no stored order")
|
|
}
|