271 lines
15 KiB
Go
271 lines
15 KiB
Go
package companion
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
type configPortFixture struct {
|
|
fields map[string]string
|
|
patches []ConfigFieldPatch
|
|
}
|
|
|
|
func (fixture *configPortFixture) ReadConfig(context.Context) (map[string]string, error) {
|
|
return fixture.fields, nil
|
|
}
|
|
func (fixture *configPortFixture) ApplyConfigPatch(_ context.Context, _ string, fields []ConfigFieldPatch) (map[string]string, error) {
|
|
fixture.patches = fields
|
|
return map[string]string{"ServerName": "Moon", "hostPath": "C:/secret"}, nil
|
|
}
|
|
|
|
type notificationPortFixture struct {
|
|
deliveries []ue4SSPlayerNotification
|
|
accepted bool
|
|
}
|
|
|
|
type rewardPortFixture struct {
|
|
grants []RewardGrant
|
|
receipt DeliveryReceipt
|
|
err error
|
|
}
|
|
|
|
func (fixture *rewardPortFixture) DeliverReward(_ context.Context, grant RewardGrant) (DeliveryReceipt, error) {
|
|
fixture.grants = append(fixture.grants, grant)
|
|
return fixture.receipt, fixture.err
|
|
}
|
|
|
|
type eventPortFixture struct {
|
|
requests []EventStartRequest
|
|
receipt EventStartReceipt
|
|
err error
|
|
}
|
|
|
|
func (fixture *eventPortFixture) StartEvent(_ context.Context, request EventStartRequest) (EventStartReceipt, error) {
|
|
fixture.requests = append(fixture.requests, request)
|
|
return fixture.receipt, fixture.err
|
|
}
|
|
|
|
// nonProductionVehicleSpawnPortFixture is an isolated test double. It has no
|
|
// network, socket, credential, or raw-command entry point; it can observe only
|
|
// the Companion's private typed request and return a bounded receipt.
|
|
type nonProductionVehicleSpawnPortFixture struct {
|
|
requests []ue4SSVehicleSpawn
|
|
receipt UE4SSVehicleSpawnReceipt
|
|
err error
|
|
}
|
|
|
|
func (fixture *nonProductionVehicleSpawnPortFixture) SpawnVehicle(_ context.Context, request ue4SSVehicleSpawn) (UE4SSVehicleSpawnReceipt, error) {
|
|
fixture.requests = append(fixture.requests, request)
|
|
return fixture.receipt, fixture.err
|
|
}
|
|
|
|
func (fixture *notificationPortFixture) SendPlayerNotification(_ context.Context, notification ue4SSPlayerNotification) (UE4SSNotificationReceipt, error) {
|
|
fixture.deliveries = append(fixture.deliveries, notification)
|
|
return UE4SSNotificationReceipt{Accepted: fixture.accepted}, nil
|
|
}
|
|
|
|
func TestRuntimeAdapterUsesOnlyLogicalConfigValuesAndRedactsDiagnostics(t *testing.T) {
|
|
port := &configPortFixture{fields: map[string]string{"ServerName": "Moon", "hostPath": "C:/secret", "Password": "nope"}}
|
|
adapter := RuntimeAdapter{Config: port, DiagnosticsState: map[string]string{"status": "healthy", "hostPath": "C:/secret"}}
|
|
read, err := adapter.ReadConfiguration(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("read config: %v", err)
|
|
}
|
|
fields := read["fields"].(map[string]string)
|
|
if fields["ServerName"] != "Moon" || len(fields) != 1 {
|
|
t.Fatalf("unsafe config was exposed: %+v", fields)
|
|
}
|
|
patched, err := adapter.PatchConfiguration(context.Background(), map[string]any{"revision": "r1", "fields": []any{map[string]any{"key": "ServerName", "value": "Moon"}}})
|
|
if err != nil {
|
|
t.Fatalf("patch config: %v", err)
|
|
}
|
|
if len(port.patches) != 1 || patched["appliedFields"].(map[string]string)["hostPath"] != "" {
|
|
t.Fatalf("patch leaked unsafe details: %+v", patched)
|
|
}
|
|
diagnostics, _ := adapter.Diagnostics(context.Background())
|
|
if diagnostics["hostPath"] != nil || diagnostics["status"] != "healthy" {
|
|
t.Fatalf("diagnostics leaked unsafe details: %+v", diagnostics)
|
|
}
|
|
}
|
|
|
|
func TestRewardDeliveryAcceptsRealSCUMCatalogCodesAndReturnsDeclaredResult(t *testing.T) {
|
|
port := &rewardPortFixture{receipt: DeliveryReceipt{Outcome: "delivered", DeliveryID: "delivery-1"}}
|
|
adapter := RuntimeAdapter{Rewards: port}
|
|
result, err := adapter.DeliverReward(context.Background(), map[string]any{
|
|
"grantId": "grant-1", "playerId": "76561198000000001",
|
|
"items": []any{map[string]any{"catalogCode": "BPC_Improvised_Backpack.01", "quantity": float64(2)}},
|
|
"operations": []any{"#SpawnItem BPC_Improvised_Backpack.01 2"},
|
|
})
|
|
if err != nil || result["accepted"] != true || result["status"] != "delivered" || result["deliveryId"] != "delivery-1" {
|
|
t.Fatalf("reward result did not match the bridge schema: result=%+v err=%v", result, err)
|
|
}
|
|
if len(port.grants) != 1 || port.grants[0].Items[0] != (RewardItem{CatalogCode: "BPC_Improvised_Backpack.01", Quantity: 2}) || len(port.grants[0].Operations) != 1 || port.grants[0].Operations[0] != "#SpawnItem BPC_Improvised_Backpack.01 2" {
|
|
t.Fatalf("reward items or operations did not reach the typed reward port: %+v", port.grants)
|
|
}
|
|
before := len(port.grants)
|
|
if _, err := adapter.DeliverReward(context.Background(), map[string]any{
|
|
"grantId": "grant-2", "playerId": "76561198000000001",
|
|
"items": []any{map[string]any{"catalogCode": "#SpawnItem BPC_Bad", "quantity": float64(1)}},
|
|
"operations": []any{},
|
|
}); err == nil || len(port.grants) != before {
|
|
t.Fatal("invalid catalog text reached the typed reward port")
|
|
}
|
|
}
|
|
|
|
func TestRewardDeliverySupportsOperationsWithoutItemsAndRejectsEmptyGrant(t *testing.T) {
|
|
port := &rewardPortFixture{receipt: DeliveryReceipt{Outcome: "delivered"}}
|
|
adapter := RuntimeAdapter{BoundServerID: "server-1", Rewards: port}
|
|
registry := NewHandlerRegistry(HandlerAvailability{BoundServerID: "server-1", Approved: true, Capabilities: map[string]bool{"reward.deliver": true}}, adapter)
|
|
stamp := time.Now().UTC()
|
|
result, err := registry.Execute(context.Background(), ClaimedCommand{
|
|
ID: "reward-operations", ProfileKey: ProfileKey, CommandType: "reward.deliver", FencingToken: 1,
|
|
LeaseExpiresAt: stamp.Add(time.Minute), ExpiresAt: stamp.Add(time.Minute),
|
|
Payload: map[string]any{"grantId": "grant-operations", "playerId": "76561198000000001", "items": []any{}, "operations": []any{"#SetFamePoints 250"}},
|
|
})
|
|
if err != nil || result.Status != "succeeded" || result.Payload["accepted"] != true || len(port.grants) != 1 || len(port.grants[0].Items) != 0 || len(port.grants[0].Operations) != 1 || port.grants[0].Operations[0] != "#SetFamePoints 250" {
|
|
t.Fatalf("operation-only reward was not preserved: result=%+v grants=%+v err=%v", result, port.grants, err)
|
|
}
|
|
if _, err := adapter.DeliverReward(context.Background(), map[string]any{
|
|
"grantId": "grant-empty", "playerId": "76561198000000001", "items": []any{}, "operations": []any{},
|
|
}); err == nil || len(port.grants) != 1 {
|
|
t.Fatalf("empty reward reached the typed reward port: grants=%+v err=%v", port.grants, err)
|
|
}
|
|
}
|
|
|
|
func TestEventStartRequiresMatchingClassAndType(t *testing.T) {
|
|
payload := map[string]any{"eventId": "event-fixed", "eventType": "fixed", "class": float64(2), "title": "Fixed Event", "placard": "Hold the point", "percent": float64(100), "produces": []any{}, "durationSeconds": float64(600)}
|
|
request, err := eventStartRequest(payload)
|
|
if err != nil || request.EventType != "fixed" || request.Class != 2 {
|
|
t.Fatalf("fixed class event was not accepted: request=%+v err=%v", request, err)
|
|
}
|
|
payload["class"] = float64(1)
|
|
if _, err := eventStartRequest(payload); err == nil {
|
|
t.Fatal("divergent event class and type was accepted")
|
|
}
|
|
}
|
|
|
|
func TestEventStartHandlerInvokesTypedPortAndReturnsCachedCommandResult(t *testing.T) {
|
|
stamp := time.Now().UTC()
|
|
port := &eventPortFixture{receipt: EventStartReceipt{Accepted: true, Status: "started", EventID: "event-1", Message: "range event started"}}
|
|
adapter := RuntimeAdapter{BoundServerID: "server-1", Events: port}
|
|
registry := NewHandlerRegistry(HandlerAvailability{BoundServerID: "server-1", Approved: true, Capabilities: map[string]bool{"event.start": true}}, adapter)
|
|
command := ClaimedCommand{
|
|
ID: "event-command-1", ProfileKey: ProfileKey, CommandType: "event.start", FencingToken: 1,
|
|
LeaseExpiresAt: stamp.Add(time.Minute), ExpiresAt: stamp.Add(time.Minute),
|
|
Payload: map[string]any{"eventId": "event-1", "eventType": "range", "class": float64(1), "title": "Friday Range", "placard": "Event starting", "percent": float64(75), "npc": float64(2), "item": float64(3), "zombie": float64(4), "animal": float64(1), "produces": []any{map[string]any{"tradeGoodsId": "cargo-drop", "percent": float64(80), "value": float64(2), "r": float64(500), "x": float64(1000), "y": float64(2000), "z": float64(300)}}, "durationSeconds": float64(1800), "maxParticipants": float64(40), "announce": true},
|
|
}
|
|
for range 2 {
|
|
result, err := registry.Execute(context.Background(), command)
|
|
if err != nil || result.Status != "succeeded" || result.Payload["accepted"] != true || result.Payload["status"] != "started" || result.Payload["eventId"] != "event-1" {
|
|
t.Fatalf("event.start did not return its executable result: result=%+v err=%v", result, err)
|
|
}
|
|
}
|
|
if len(port.requests) != 1 {
|
|
t.Fatalf("event.start handler did not execute exactly once: %+v", port.requests)
|
|
}
|
|
request := port.requests[0]
|
|
if request.EventID != "event-1" || request.EventType != "range" || request.Class != 1 || request.Title != "Friday Range" || request.Placard != "Event starting" || request.Percent != 75 || request.NPC != 2 || request.Item != 3 || request.Zombie != 4 || request.Animal != 1 || len(request.Produces) != 1 || request.Produces[0].TradeGoodsID != "cargo-drop" || request.DurationSeconds != 1800 || request.MaxParticipants != 40 || !request.Announce {
|
|
t.Fatalf("event.start payload did not reach the typed event port: %+v", request)
|
|
}
|
|
}
|
|
|
|
func TestUE4SSNotificationIsTypedAndRedacted(t *testing.T) {
|
|
port := ¬ificationPortFixture{accepted: true}
|
|
adapter := RuntimeAdapter{BoundServerID: "server-1", Notification: port}
|
|
result, err := adapter.NotifyPlayer(context.Background(), map[string]any{"playerId": "76561198000000001", "message": "Moon \"gift\""})
|
|
if err != nil || !result["accepted"].(bool) || len(port.deliveries) != 1 {
|
|
t.Fatalf("typed notification was not delivered: result=%+v err=%v deliveries=%+v", result, err, port.deliveries)
|
|
}
|
|
delivery := port.deliveries[0]
|
|
if delivery.ServerID != "server-1" || delivery.chatType != fixedNotificationType || delivery.protectedAuditCommand != "SendChat 4 \"Moon \\\"gift\\\"\" 76561198000000001" {
|
|
t.Fatalf("notification did not use the fixed UE4SS contract: %+v", delivery)
|
|
}
|
|
if result["message"] == delivery.protectedAuditCommand || result["command"] != nil || result["rcon"] != nil {
|
|
t.Fatalf("notification leaked protected transport details: %+v", result)
|
|
}
|
|
}
|
|
|
|
func TestRuntimeNotificationRejectsInvalidRecipient(t *testing.T) {
|
|
port := ¬ificationPortFixture{accepted: true}
|
|
adapter := RuntimeAdapter{BoundServerID: "server-1", Notification: port}
|
|
if _, err := adapter.NotifyPlayer(context.Background(), map[string]any{"playerId": "not-a-steam-id", "message": "Moonlight"}); err == nil {
|
|
t.Fatal("unverified recipient identity must be rejected")
|
|
}
|
|
}
|
|
|
|
func TestNotificationFailureIsCachedWithoutInvokingRewardDelivery(t *testing.T) {
|
|
stamp := time.Now().UTC()
|
|
port := ¬ificationPortFixture{accepted: false}
|
|
adapter := RuntimeAdapter{BoundServerID: "server-1", Notification: port}
|
|
registry := NewHandlerRegistry(HandlerAvailability{BoundServerID: "server-1", Approved: true, Capabilities: map[string]bool{"player.notify": true}}, adapter)
|
|
command := ClaimedCommand{ID: "notification-1", ProfileKey: ProfileKey, CommandType: "player.notify", Payload: map[string]any{"playerId": "76561198000000001", "message": "Moonlight"}, FencingToken: 1, LeaseExpiresAt: stamp.Add(time.Minute), ExpiresAt: stamp.Add(time.Minute)}
|
|
for range 2 {
|
|
result, err := registry.Execute(context.Background(), command)
|
|
if err != nil || result.Payload["accepted"] != false {
|
|
t.Fatalf("notification failure was not typed: result=%+v err=%v", result, err)
|
|
}
|
|
}
|
|
if len(port.deliveries) != 1 {
|
|
t.Fatalf("duplicate notification attempted transport %d times", len(port.deliveries))
|
|
}
|
|
}
|
|
|
|
func TestVersionedVehicleSpawnUsesFixedTemplateAndPrivateAuditOnly(t *testing.T) {
|
|
port := &nonProductionVehicleSpawnPortFixture{receipt: UE4SSVehicleSpawnReceipt{Outcome: UE4SSVehicleSpawnAccepted}}
|
|
adapter := RuntimeAdapter{BoundServerID: "server-1", VehicleSpawn: port}
|
|
result, err := adapter.SpawnVehicle(context.Background(), map[string]any{"vehicleCode": "BPC_Laika_C"})
|
|
if err != nil || result["outcome"] != "succeeded" || len(port.requests) != 1 {
|
|
t.Fatalf("fixed vehicle spawn was not delivered: result=%+v err=%v requests=%+v", result, err, port.requests)
|
|
}
|
|
request := port.requests[0]
|
|
if request.ServerID != "server-1" || request.VehicleCode != "BPC_Laika_C" || request.protectedAuditCommand != "#spawnvehicle BPC_Laika_C" {
|
|
t.Fatalf("vehicle spawn did not use the fixed template: %+v", request)
|
|
}
|
|
if result["command"] != nil || result["rcon"] != nil || result["audit"] != nil || result["outcome"] == request.protectedAuditCommand {
|
|
t.Fatalf("vehicle spawn leaked protected transport details: %+v", result)
|
|
}
|
|
}
|
|
|
|
func TestVersionedVehicleSpawnFailsClosedAndClassifiesBoundedReceipts(t *testing.T) {
|
|
port := &nonProductionVehicleSpawnPortFixture{receipt: UE4SSVehicleSpawnReceipt{Outcome: UE4SSVehicleSpawnRejected}}
|
|
adapter := RuntimeAdapter{BoundServerID: "server-1", VehicleSpawn: port}
|
|
for name, testCase := range map[string]struct {
|
|
outcome string
|
|
receipt UE4SSVehicleSpawnReceipt
|
|
err error
|
|
}{
|
|
"failed": {outcome: "failed", receipt: UE4SSVehicleSpawnReceipt{Outcome: UE4SSVehicleSpawnRejected}},
|
|
"unknown": {outcome: "unknown", receipt: UE4SSVehicleSpawnReceipt{Outcome: UE4SSVehicleSpawnUnknown}},
|
|
"unknown-transport": {outcome: "unknown", receipt: UE4SSVehicleSpawnReceipt{}, err: errors.New("isolated transport timeout")},
|
|
} {
|
|
port.receipt, port.err = testCase.receipt, testCase.err
|
|
result, err := adapter.SpawnVehicle(context.Background(), map[string]any{"vehicleCode": "BPC_WolfsWagen_C"})
|
|
if err != nil || result["outcome"] != testCase.outcome {
|
|
t.Fatalf("receipt %s was not safely classified: result=%+v err=%v", name, result, err)
|
|
}
|
|
}
|
|
before := len(port.requests)
|
|
if _, err := adapter.SpawnVehicle(context.Background(), map[string]any{"vehicleCode": "#spawnvehicle BPC_Laika_C"}); err == nil || len(port.requests) != before {
|
|
t.Fatal("raw command text must not reach the vehicle transport")
|
|
}
|
|
}
|
|
|
|
func TestVehicleSpawnUnknownOutcomeIsCachedWithoutRetry(t *testing.T) {
|
|
stamp := time.Now().UTC()
|
|
port := &nonProductionVehicleSpawnPortFixture{receipt: UE4SSVehicleSpawnReceipt{Outcome: UE4SSVehicleSpawnUnknown}}
|
|
adapter := RuntimeAdapter{BoundServerID: "server-1", VehicleSpawn: port}
|
|
registry := NewHandlerRegistry(HandlerAvailability{BoundServerID: "server-1", Approved: true, Capabilities: map[string]bool{"vehicle.spawn": true}}, adapter)
|
|
command := ClaimedCommand{ID: "vehicle-unknown-1", ProfileKey: ProfileKey, CommandType: "vehicle.spawn", Payload: map[string]any{"vehicleCode": "BPC_Laika_C"}, FencingToken: 1, LeaseExpiresAt: stamp.Add(time.Minute), ExpiresAt: stamp.Add(time.Minute)}
|
|
for range 2 {
|
|
result, err := registry.Execute(context.Background(), command)
|
|
if err != nil || result.Payload["outcome"] != "unknown" {
|
|
t.Fatalf("unknown vehicle outcome was not retained: result=%+v err=%v", result, err)
|
|
}
|
|
}
|
|
if len(port.requests) != 1 {
|
|
t.Fatalf("unknown vehicle outcome retried transport %d times", len(port.requests))
|
|
}
|
|
}
|