Ilia Denisov
ebd156ece2
Tests · UI / test (push) Has been cancelled
Tests · Go / test (pull_request) Successful in 2m6s
Tests · Go / test (push) Successful in 2m7s
Tests · Integration / integration (pull_request) Successful in 1m47s
Tests · UI / test (pull_request) Failing after 3m42s
The Phase 27 BattleViewer was the last UI surface still issuing raw
fetch() against the backend REST contract (`/api/v1/user/games/...
/battles/...`). The dev-deploy gateway never proxied that path, so
the viewer worked only in tools/local-dev/. Move it onto the signed
ConnectRPC channel every other authenticated surface already uses.
Wire pieces:
- FBS GameBattleRequest in pkg/schema/fbs/battle.fbs, regenerated
Go + TS bindings.
- MessageTypeUserGamesBattle constant + GameBattleRequest struct in
pkg/model/report/messages.go.
- pkg/transcoder/battle.go gains GameBattleRequestToPayload and
PayloadToGameBattleRequest helpers.
- gateway games_commands.go switches on the new message type and
GETs /api/v1/user/games/{id}/battles/{turn}/{battle_id}; the JSON
response is re-encoded as a FlatBuffers BattleReport before being
returned. 404 from backend surfaces as the canonical `not_found`
gateway error.
- ui/frontend/src/api/battle-fetch.ts now builds the FBS request,
calls GalaxyClient.executeCommand, and decodes the FBS response
into the existing UI shape (Record<string,string> race/ship maps,
string-form UUID). BattleFetchError carries an HTTP-style status
derived from the result code so the active-view's not_found branch
keeps working.
- battle.svelte pulls the GalaxyClient from the in-game shell
context. While the layout's boot Promise.all is in flight the
effect stays in `loading` until the client handle becomes
non-null.
- ui/Makefile FBS_INPUTS gains battle.fbs.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
261 lines
9.2 KiB
Go
261 lines
9.2 KiB
Go
package backendclient_test
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
|
|
"galaxy/gateway/internal/backendclient"
|
|
"galaxy/gateway/internal/downstream"
|
|
ordermodel "galaxy/model/order"
|
|
reportmodel "galaxy/model/report"
|
|
"galaxy/transcoder"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestExecuteUserGamesOrderForwardsAndDecodesResponse(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
gameID := uuid.MustParse("11111111-2222-3333-4444-555555555555")
|
|
applied := true
|
|
source := &ordermodel.UserGamesOrder{
|
|
GameID: gameID,
|
|
Commands: []ordermodel.DecodableCommand{
|
|
&ordermodel.CommandPlanetRename{
|
|
CommandMeta: ordermodel.CommandMeta{
|
|
CmdType: ordermodel.CommandTypePlanetRename,
|
|
CmdID: "00000000-0000-0000-0000-00000000aaaa",
|
|
},
|
|
Number: 7,
|
|
Name: "alpha",
|
|
},
|
|
},
|
|
}
|
|
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
require.Equal(t, http.MethodPost, r.Method)
|
|
require.Equal(t, "/api/v1/user/games/"+gameID.String()+"/orders", r.URL.Path)
|
|
require.Equal(t, "user-1", r.Header.Get(backendclient.HeaderUserID))
|
|
writeJSON(t, w, http.StatusAccepted, map[string]any{
|
|
"game_id": gameID.String(),
|
|
"updatedAt": int64(99),
|
|
"cmd": []map[string]any{{
|
|
"@type": string(ordermodel.CommandTypePlanetRename),
|
|
"cmdId": "00000000-0000-0000-0000-00000000aaaa",
|
|
"cmdApplied": applied,
|
|
"planetNumber": 7,
|
|
"name": "alpha",
|
|
}},
|
|
})
|
|
}))
|
|
t.Cleanup(server.Close)
|
|
|
|
client := newRESTClient(t, server)
|
|
payload, err := transcoder.UserGamesOrderToPayload(source)
|
|
require.NoError(t, err)
|
|
cmd := newAuthCommand(t, ordermodel.MessageTypeUserGamesOrder, payload)
|
|
result, err := client.ExecuteGameCommand(context.Background(), cmd)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "ok", result.ResultCode)
|
|
|
|
decoded, err := transcoder.PayloadToUserGamesOrderResponse(result.PayloadBytes)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, decoded)
|
|
assert.Equal(t, gameID, decoded.GameID)
|
|
assert.Equal(t, int64(99), decoded.UpdatedAt)
|
|
require.Len(t, decoded.Commands, 1)
|
|
rename, ok := ordermodel.AsCommand[*ordermodel.CommandPlanetRename](decoded.Commands[0])
|
|
require.True(t, ok)
|
|
assert.Equal(t, "00000000-0000-0000-0000-00000000aaaa", rename.CmdID)
|
|
require.NotNil(t, rename.CmdApplied)
|
|
assert.True(t, *rename.CmdApplied)
|
|
}
|
|
|
|
func TestExecuteUserGamesOrderGetReturnsStored(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
gameID := uuid.MustParse("22222222-3333-4444-5555-666666666666")
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
require.Equal(t, http.MethodGet, r.Method)
|
|
require.Equal(t, "/api/v1/user/games/"+gameID.String()+"/orders", r.URL.Path)
|
|
require.Equal(t, "5", r.URL.Query().Get("turn"))
|
|
writeJSON(t, w, http.StatusOK, map[string]any{
|
|
"game_id": gameID.String(),
|
|
"updatedAt": int64(42),
|
|
"cmd": []map[string]any{{
|
|
"@type": string(ordermodel.CommandTypePlanetRename),
|
|
"cmdId": "00000000-0000-0000-0000-00000000bbbb",
|
|
"planetNumber": 9,
|
|
"name": "stored",
|
|
}},
|
|
})
|
|
}))
|
|
t.Cleanup(server.Close)
|
|
|
|
client := newRESTClient(t, server)
|
|
payload, err := transcoder.UserGamesOrderGetToPayload(&ordermodel.UserGamesOrderGet{GameID: gameID, Turn: 5})
|
|
require.NoError(t, err)
|
|
result, err := client.ExecuteGameCommand(context.Background(), newAuthCommand(t, ordermodel.MessageTypeUserGamesOrderGet, payload))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "ok", result.ResultCode)
|
|
|
|
stored, found, err := transcoder.PayloadToUserGamesOrderGetResponse(result.PayloadBytes)
|
|
require.NoError(t, err)
|
|
require.True(t, found)
|
|
require.NotNil(t, stored)
|
|
assert.Equal(t, gameID, stored.GameID)
|
|
assert.Equal(t, int64(42), stored.UpdatedAt)
|
|
require.Len(t, stored.Commands, 1)
|
|
rename, ok := ordermodel.AsCommand[*ordermodel.CommandPlanetRename](stored.Commands[0])
|
|
require.True(t, ok)
|
|
assert.Equal(t, 9, rename.Number)
|
|
assert.Equal(t, "stored", rename.Name)
|
|
}
|
|
|
|
func TestExecuteUserGamesOrderGetMapsNoContent(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
gameID := uuid.MustParse("33333333-4444-5555-6666-777777777777")
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
require.Equal(t, "11", r.URL.Query().Get("turn"))
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}))
|
|
t.Cleanup(server.Close)
|
|
|
|
client := newRESTClient(t, server)
|
|
payload, err := transcoder.UserGamesOrderGetToPayload(&ordermodel.UserGamesOrderGet{GameID: gameID, Turn: 11})
|
|
require.NoError(t, err)
|
|
result, err := client.ExecuteGameCommand(context.Background(), newAuthCommand(t, ordermodel.MessageTypeUserGamesOrderGet, payload))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "ok", result.ResultCode)
|
|
|
|
stored, found, err := transcoder.PayloadToUserGamesOrderGetResponse(result.PayloadBytes)
|
|
require.NoError(t, err)
|
|
assert.False(t, found)
|
|
assert.Nil(t, stored)
|
|
}
|
|
|
|
func TestExecuteUserGamesOrderGetRejectsNegativeTurn(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
t.Fatal("server must not be hit on negative turn")
|
|
}))
|
|
t.Cleanup(server.Close)
|
|
|
|
client := newRESTClient(t, server)
|
|
gameID := uuid.MustParse("44444444-5555-6666-7777-888888888888")
|
|
// PayloadToUserGamesOrderGet rejects negative turns at decode
|
|
// time; force the negative case by hand-crafting a payload via
|
|
// the encoder set to 0 then mutating the buffer is fragile, so
|
|
// instead exercise the encoder's own non-negative check.
|
|
_, err := transcoder.UserGamesOrderGetToPayload(&ordermodel.UserGamesOrderGet{GameID: gameID, Turn: -1})
|
|
require.Error(t, err)
|
|
|
|
// And verify the dispatch path also surfaces the encoder error
|
|
// when wrapping a manually-signed envelope: the request payload
|
|
// is empty so the decoder reports "data is empty", which the
|
|
// dispatcher wraps with the message-type prefix.
|
|
_, err = client.ExecuteGameCommand(context.Background(), downstream.AuthenticatedCommand{
|
|
MessageType: ordermodel.MessageTypeUserGamesOrderGet,
|
|
PayloadBytes: nil,
|
|
UserID: "user-1",
|
|
})
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "user.games.order.get")
|
|
}
|
|
|
|
func TestExecuteUserGamesBattleForwardsAndDecodesResponse(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
gameID := uuid.MustParse("66666666-7777-8888-9999-aaaaaaaaaaaa")
|
|
battleID := uuid.MustParse("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")
|
|
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
require.Equal(t, http.MethodGet, r.Method)
|
|
require.Equal(t,
|
|
"/api/v1/user/games/"+gameID.String()+"/battles/7/"+battleID.String(),
|
|
r.URL.Path,
|
|
)
|
|
require.Equal(t, "user-1", r.Header.Get(backendclient.HeaderUserID))
|
|
raceID := uuid.MustParse("11111111-2222-3333-4444-555555555555")
|
|
writeJSON(t, w, http.StatusOK, map[string]any{
|
|
"id": battleID.String(),
|
|
"planet": uint(42),
|
|
"planetName": "Tau Ceti II",
|
|
"races": map[string]string{"1": raceID.String()},
|
|
"ships": map[string]map[string]any{},
|
|
"protocol": []any{},
|
|
})
|
|
}))
|
|
t.Cleanup(server.Close)
|
|
|
|
client := newRESTClient(t, server)
|
|
payload, err := transcoder.GameBattleRequestToPayload(&reportmodel.GameBattleRequest{
|
|
GameID: gameID,
|
|
Turn: 7,
|
|
BattleID: battleID,
|
|
})
|
|
require.NoError(t, err)
|
|
result, err := client.ExecuteGameCommand(context.Background(), newAuthCommand(t, reportmodel.MessageTypeUserGamesBattle, payload))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "ok", result.ResultCode)
|
|
|
|
decoded, err := transcoder.PayloadToBattleReport(result.PayloadBytes)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, decoded)
|
|
assert.Equal(t, battleID, decoded.ID)
|
|
assert.Equal(t, uint(42), decoded.Planet)
|
|
assert.Equal(t, "Tau Ceti II", decoded.PlanetName)
|
|
}
|
|
|
|
func TestExecuteUserGamesBattleMapsNotFound(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
gameID := uuid.MustParse("77777777-8888-9999-aaaa-bbbbbbbbbbbb")
|
|
battleID := uuid.MustParse("99999999-aaaa-bbbb-cccc-dddddddddddd")
|
|
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
writeJSON(t, w, http.StatusNotFound, map[string]any{
|
|
"error": map[string]any{
|
|
"code": "not_found",
|
|
"message": "battle not found",
|
|
},
|
|
})
|
|
}))
|
|
t.Cleanup(server.Close)
|
|
|
|
client := newRESTClient(t, server)
|
|
payload, err := transcoder.GameBattleRequestToPayload(&reportmodel.GameBattleRequest{
|
|
GameID: gameID,
|
|
Turn: 2,
|
|
BattleID: battleID,
|
|
})
|
|
require.NoError(t, err)
|
|
result, err := client.ExecuteGameCommand(context.Background(), newAuthCommand(t, reportmodel.MessageTypeUserGamesBattle, payload))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "not_found", result.ResultCode)
|
|
}
|
|
|
|
// writeJSON copy below mirrors the helper used by other test files
|
|
// in this package; keeping it adjacent to its callers avoids
|
|
// reaching across files in a fresh test.
|
|
//
|
|
// TODO(phase14): collapse the two writeJSON copies once the package
|
|
// gains a shared `helpers_test.go`. Phase 14 keeps the duplicate to
|
|
// avoid touching unrelated tests.
|
|
var _ = json.Marshal // keep encoding/json import if writeJSON is hoisted
|
|
|
|
func init() {
|
|
// Sanity-check that the package-level writeJSON helper is
|
|
// declared by another _test.go file we depend on; if a future
|
|
// refactor removes it, this test file will not compile.
|
|
_ = strings.TrimSpace
|
|
}
|