433 lines
16 KiB
PHP
433 lines
16 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace BattleForge\Tests\Integration;
|
|
|
|
use BattleForge\Application\ScenarioSerializer;
|
|
use BattleForge\Application\TurnToken;
|
|
use BattleForge\Domain\Archetype;
|
|
use BattleForge\Domain\Battlefield;
|
|
use BattleForge\Domain\MatchState;
|
|
use BattleForge\Domain\Position;
|
|
use BattleForge\Domain\UnitState;
|
|
use BattleForge\Http\CsrfToken;
|
|
use BattleForge\Http\Handlers\PostMatchAbility;
|
|
use BattleForge\Http\Handlers\PostMatchAttack;
|
|
use BattleForge\Http\Handlers\PostMatchEndTurn;
|
|
use BattleForge\Http\Handlers\PostMatchMove;
|
|
use BattleForge\Http\Request;
|
|
use PHPUnit\Framework\TestCase;
|
|
|
|
final class PostMatchActionTest extends TestCase
|
|
{
|
|
private const SECRET = 'match-action-test-secret';
|
|
private const MATCH_ID = '0123456789abcdef';
|
|
private const HEAL = ['heal'];
|
|
|
|
public function testMoveHappyPathReturnsTheUpdatedMatchAndAFreshTurnToken(): void
|
|
{
|
|
$match = $this->freshMatch();
|
|
$token = $this->tokenFor($match);
|
|
[$csrf, $cookie] = CsrfToken::issue(self::SECRET);
|
|
|
|
$response = (new PostMatchMove(self::SECRET))->handle(
|
|
$this->buildRequest(
|
|
match: $match,
|
|
csrf: $csrf,
|
|
turnToken: $token,
|
|
cookies: ['__csrf' => $cookie, '__csrf_token' => $token],
|
|
body: [
|
|
'matchId' => self::MATCH_ID,
|
|
'match' => ScenarioSerializer::matchToArray($match),
|
|
'unitId' => 'alpha-1',
|
|
'x' => 1,
|
|
'y' => 0,
|
|
],
|
|
),
|
|
[],
|
|
);
|
|
|
|
self::assertSame(200, $response->status);
|
|
$body = json_decode($response->body, true);
|
|
$posKey = $body['match']['units'][0]['position']['x'] . ':' . $body['match']['units'][0]['position']['y'];
|
|
self::assertSame('1:0', $posKey);
|
|
self::assertMatchesRegularExpression('/^[a-f0-9]{32}$/', $body['turnToken']);
|
|
self::assertNull($body['winnerTeamId']);
|
|
}
|
|
|
|
public function testMoveRejectsAnUnreachableDestinationAndDoesNotMutateTheMatch(): void
|
|
{
|
|
$match = $this->freshMatch();
|
|
$token = $this->tokenFor($match);
|
|
[$csrf, $cookie] = CsrfToken::issue(self::SECRET);
|
|
|
|
$response = (new PostMatchMove(self::SECRET))->handle(
|
|
$this->buildRequest(
|
|
match: $match,
|
|
csrf: $csrf,
|
|
turnToken: $token,
|
|
cookies: ['__csrf' => $cookie, '__csrf_token' => $token],
|
|
body: [
|
|
'matchId' => self::MATCH_ID,
|
|
'match' => ScenarioSerializer::matchToArray($match),
|
|
'unitId' => 'alpha-1',
|
|
'x' => 0,
|
|
'y' => 0,
|
|
],
|
|
),
|
|
[],
|
|
);
|
|
|
|
self::assertSame(409, $response->status);
|
|
$body = json_decode($response->body, true);
|
|
self::assertStringContainsString('not reachable', $body['error']);
|
|
$posKey = $body['match']['units'][0]['position']['x'] . ':' . $body['match']['units'][0]['position']['y'];
|
|
self::assertSame('0:0', $posKey);
|
|
}
|
|
|
|
public function testAttackHappyPathReducesTargetHealth(): void
|
|
{
|
|
$match = $this->freshMatch();
|
|
$matchArray = ScenarioSerializer::matchToArray($match);
|
|
$matchArray['units'][0]['position'] = ['x' => 6, 'y' => 7];
|
|
$match = ScenarioSerializer::matchFromArray($matchArray);
|
|
|
|
// Loop until a hit lands; the to-hit roll can miss.
|
|
$bravo = null;
|
|
for ($i = 0; $i < 200; $i += 1) {
|
|
$match = $this->freshMatch();
|
|
$matchArray = ScenarioSerializer::matchToArray($match);
|
|
$matchArray['units'][0]['position'] = ['x' => 6, 'y' => 7];
|
|
$match = ScenarioSerializer::matchFromArray($matchArray);
|
|
$token = $this->tokenFor($match);
|
|
[$csrf, $cookie] = CsrfToken::issue(self::SECRET);
|
|
|
|
$response = (new PostMatchAttack(self::SECRET))->handle(
|
|
$this->buildRequest(
|
|
match: $match,
|
|
csrf: $csrf,
|
|
turnToken: $token,
|
|
cookies: ['__csrf' => $cookie, '__csrf_token' => $token],
|
|
body: [
|
|
'matchId' => self::MATCH_ID,
|
|
'match' => ScenarioSerializer::matchToArray($match),
|
|
'attackerId' => 'alpha-1',
|
|
'targetId' => 'bravo-1',
|
|
],
|
|
),
|
|
[],
|
|
);
|
|
|
|
self::assertSame(200, $response->status);
|
|
$body = json_decode($response->body, true);
|
|
$bravo = null;
|
|
foreach ($body['match']['units'] as $unit) {
|
|
if ($unit['id'] === 'bravo-1') {
|
|
$bravo = $unit;
|
|
break;
|
|
}
|
|
}
|
|
if ($bravo !== null && $bravo['health'] < 10) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
self::assertNotNull($bravo);
|
|
self::assertLessThan(10, $bravo['health']);
|
|
}
|
|
|
|
public function testAttackRejectsAnOutOfRangeTarget(): void
|
|
{
|
|
$match = $this->freshMatch();
|
|
$token = $this->tokenFor($match);
|
|
[$csrf, $cookie] = CsrfToken::issue(self::SECRET);
|
|
|
|
$response = (new PostMatchAttack(self::SECRET))->handle(
|
|
$this->buildRequest(
|
|
match: $match,
|
|
csrf: $csrf,
|
|
turnToken: $token,
|
|
cookies: ['__csrf' => $cookie, '__csrf_token' => $token],
|
|
body: [
|
|
'matchId' => self::MATCH_ID,
|
|
'match' => ScenarioSerializer::matchToArray($match),
|
|
'attackerId' => 'alpha-1',
|
|
'targetId' => 'bravo-1',
|
|
],
|
|
),
|
|
[],
|
|
);
|
|
|
|
self::assertSame(409, $response->status);
|
|
}
|
|
|
|
public function testAbilityHappyPathHealsAnAlly(): void
|
|
{
|
|
$match = $this->freshMatch();
|
|
$matchArray = ScenarioSerializer::matchToArray($match);
|
|
foreach ($matchArray['units'] as &$unit) {
|
|
if ($unit['id'] === 'alpha-3') {
|
|
$unit['archetype'] = 'support';
|
|
$unit['abilities'] = ['heal'];
|
|
}
|
|
}
|
|
unset($unit);
|
|
foreach ($matchArray['units'] as &$unit) {
|
|
if ($unit['id'] === 'alpha-2') {
|
|
$unit['health'] = 2;
|
|
}
|
|
}
|
|
unset($unit);
|
|
$match = ScenarioSerializer::matchFromArray($matchArray);
|
|
$token = $this->tokenFor($match);
|
|
[$csrf, $cookie] = CsrfToken::issue(self::SECRET);
|
|
|
|
$response = (new PostMatchAbility(self::SECRET))->handle(
|
|
$this->buildRequest(
|
|
match: $match,
|
|
csrf: $csrf,
|
|
turnToken: $token,
|
|
cookies: ['__csrf' => $cookie, '__csrf_token' => $token],
|
|
body: [
|
|
'matchId' => self::MATCH_ID,
|
|
'match' => ScenarioSerializer::matchToArray($match),
|
|
'unitId' => 'alpha-3',
|
|
'abilityId' => 'heal',
|
|
'x' => 0,
|
|
'y' => 1,
|
|
],
|
|
),
|
|
[],
|
|
);
|
|
|
|
self::assertSame(200, $response->status);
|
|
$body = json_decode($response->body, true);
|
|
$healed = null;
|
|
foreach ($body['match']['units'] as $unit) {
|
|
if ($unit['id'] === 'alpha-2') {
|
|
$healed = $unit;
|
|
break;
|
|
}
|
|
}
|
|
self::assertGreaterThan(2, $healed['health']);
|
|
}
|
|
|
|
public function testAbilityRejectsATargetOutsideRange(): void
|
|
{
|
|
$match = $this->freshMatch();
|
|
$matchArray = ScenarioSerializer::matchToArray($match);
|
|
foreach ($matchArray['units'] as &$unit) {
|
|
if ($unit['id'] === 'alpha-3') {
|
|
$unit['archetype'] = 'support';
|
|
$unit['abilities'] = ['heal'];
|
|
}
|
|
}
|
|
unset($unit);
|
|
$match = ScenarioSerializer::matchFromArray($matchArray);
|
|
$token = $this->tokenFor($match);
|
|
[$csrf, $cookie] = CsrfToken::issue(self::SECRET);
|
|
|
|
$response = (new PostMatchAbility(self::SECRET))->handle(
|
|
$this->buildRequest(
|
|
match: $match,
|
|
csrf: $csrf,
|
|
turnToken: $token,
|
|
cookies: ['__csrf' => $cookie, '__csrf_token' => $token],
|
|
body: [
|
|
'matchId' => self::MATCH_ID,
|
|
'match' => ScenarioSerializer::matchToArray($match),
|
|
'unitId' => 'alpha-3',
|
|
'abilityId' => 'heal',
|
|
'x' => 7,
|
|
'y' => 7,
|
|
],
|
|
),
|
|
[],
|
|
);
|
|
|
|
self::assertSame(409, $response->status);
|
|
}
|
|
|
|
public function testMoveIntoWaterEndsTurn(): void
|
|
{
|
|
// Build a match where alpha-1 is on dry ground next to a water tile;
|
|
// alpha-2 and alpha-3 are parked out of the way so the move path is
|
|
// clear, and the move target (0,1) becomes a water tile whose cost (3)
|
|
// matches alpha-1's speed budget.
|
|
$match = $this->freshMatch();
|
|
$matchArray = ScenarioSerializer::matchToArray($match);
|
|
$matchArray['units'][0]['position'] = ['x' => 0, 'y' => 0];
|
|
$matchArray['units'][0]['speed'] = 3;
|
|
$matchArray['units'][1]['position'] = ['x' => 0, 'y' => 3]; // alpha-2 clear of alpha-1's path
|
|
$matchArray['units'][2]['position'] = ['x' => 0, 'y' => 2]; // alpha-3 clear of alpha-1's path
|
|
$matchArray['units'][3]['position'] = ['x' => 7, 'y' => 7]; // bravo-1 stays put
|
|
$matchArray['units'][4]['position'] = ['x' => 6, 'y' => 7]; // bravo-2
|
|
$matchArray['units'][5]['position'] = ['x' => 5, 'y' => 7]; // bravo-3
|
|
$matchArray['battlefield']['terrain'] = ['0:1' => 'water'];
|
|
$match = ScenarioSerializer::matchFromArray($matchArray);
|
|
|
|
$token = $this->tokenFor($match);
|
|
[$csrf, $cookie] = CsrfToken::issue(self::SECRET);
|
|
|
|
$response = (new PostMatchMove(self::SECRET))->handle(
|
|
$this->buildRequest(
|
|
match: $match,
|
|
csrf: $csrf,
|
|
turnToken: $token,
|
|
cookies: ['__csrf' => $cookie, '__csrf_token' => $token],
|
|
body: [
|
|
'matchId' => self::MATCH_ID,
|
|
'match' => ScenarioSerializer::matchToArray($match),
|
|
'unitId' => 'alpha-1',
|
|
'x' => 0,
|
|
'y' => 1,
|
|
],
|
|
),
|
|
[],
|
|
);
|
|
|
|
self::assertSame(200, $response->status);
|
|
|
|
$body = json_decode($response->body, true);
|
|
$moved = null;
|
|
foreach ($body['match']['units'] as $u) {
|
|
if ($u['id'] === 'alpha-1') {
|
|
$moved = $u;
|
|
}
|
|
}
|
|
self::assertNotNull($moved);
|
|
self::assertSame(['x' => 0, 'y' => 1], $moved['position']);
|
|
self::assertSame(0, $moved['actionsRemaining'], 'wading ends the turn');
|
|
self::assertTrue($moved['wadedThisTurn'], 'wade flag is set after water entry');
|
|
}
|
|
|
|
public function testEndTurnHappyPathSwitchesTheActiveTeamAndIncrementsTheRoundAfterBothSides(): void
|
|
{
|
|
$match = $this->freshMatch();
|
|
$token = $this->tokenFor($match);
|
|
[$csrf, $cookie] = CsrfToken::issue(self::SECRET);
|
|
|
|
$response = (new PostMatchEndTurn(self::SECRET))->handle(
|
|
$this->buildRequest(
|
|
match: $match,
|
|
csrf: $csrf,
|
|
turnToken: $token,
|
|
cookies: ['__csrf' => $cookie, '__csrf_token' => $token],
|
|
body: [
|
|
'matchId' => self::MATCH_ID,
|
|
'match' => ScenarioSerializer::matchToArray($match),
|
|
],
|
|
),
|
|
[],
|
|
);
|
|
|
|
self::assertSame(200, $response->status);
|
|
$body = json_decode($response->body, true);
|
|
self::assertSame('bravo', $body['match']['activeTeamId']);
|
|
self::assertSame(1, $body['match']['round']);
|
|
}
|
|
|
|
public function testEndTurnRejectsARequestWithAStaleTurnToken(): void
|
|
{
|
|
$match = $this->freshMatch();
|
|
$stale = TurnToken::issue(self::SECRET, self::MATCH_ID, 'alpha', 99, 0);
|
|
$wrongRound = TurnToken::issue(self::SECRET, self::MATCH_ID, 'alpha', 2, 0);
|
|
$good = $this->tokenFor($match);
|
|
[$csrf, $cookie] = CsrfToken::issue(self::SECRET);
|
|
|
|
$staleResponse = (new PostMatchEndTurn(self::SECRET))->handle(
|
|
$this->buildRequest(
|
|
match: $match,
|
|
csrf: $csrf,
|
|
turnToken: $stale,
|
|
cookies: ['__csrf' => $cookie, '__csrf_token' => $token],
|
|
body: [
|
|
'matchId' => self::MATCH_ID,
|
|
'match' => ScenarioSerializer::matchToArray($match),
|
|
],
|
|
),
|
|
[],
|
|
);
|
|
self::assertSame(409, $staleResponse->status);
|
|
$body = json_decode($staleResponse->body, true);
|
|
self::assertSame('turn', $body['error'] ?? null);
|
|
|
|
$wrongRoundResponse = (new PostMatchEndTurn(self::SECRET))->handle(
|
|
$this->buildRequest(
|
|
match: $match,
|
|
csrf: $csrf,
|
|
turnToken: $wrongRound,
|
|
cookies: ['__csrf' => $cookie, '__csrf_token' => $token],
|
|
body: [
|
|
'matchId' => self::MATCH_ID,
|
|
'match' => ScenarioSerializer::matchToArray($match),
|
|
],
|
|
),
|
|
[],
|
|
);
|
|
self::assertSame(409, $wrongRoundResponse->status);
|
|
}
|
|
|
|
private function freshMatch(): MatchState
|
|
{
|
|
$support = new UnitState(
|
|
'alpha-3',
|
|
'alpha',
|
|
new Position(1, 1),
|
|
10,
|
|
10,
|
|
3,
|
|
3,
|
|
2,
|
|
2,
|
|
false,
|
|
Archetype::Support,
|
|
self::HEAL,
|
|
);
|
|
|
|
return new MatchState(
|
|
new Battlefield(8, 8),
|
|
[
|
|
new UnitState('alpha-1', 'alpha', new Position(0, 0), 10, 10, 3, 3, 2, 2, false, Archetype::Defender),
|
|
new UnitState('alpha-2', 'alpha', new Position(0, 1), 10, 10, 3, 3, 2, 2, false, Archetype::Defender),
|
|
$support,
|
|
new UnitState('bravo-1', 'bravo', new Position(7, 7), 10, 10, 3, 3, 2, 2, false, Archetype::Striker),
|
|
new UnitState('bravo-2', 'bravo', new Position(6, 6), 10, 10, 3, 3, 2, 2, false, Archetype::Striker),
|
|
new UnitState('bravo-3', 'bravo', new Position(5, 7), 10, 10, 3, 3, 2, 2, false, Archetype::Striker),
|
|
],
|
|
'alpha',
|
|
);
|
|
}
|
|
|
|
private function tokenFor(MatchState $match): string
|
|
{
|
|
return TurnToken::issue(
|
|
self::SECRET,
|
|
self::MATCH_ID,
|
|
$match->activeTeamId,
|
|
$match->round,
|
|
count($match->actionLog),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @param array<string, string> $cookies
|
|
* @param array<string, mixed> $body
|
|
*/
|
|
private function buildRequest(
|
|
MatchState $match,
|
|
string $csrf,
|
|
string $turnToken,
|
|
array $cookies,
|
|
array $body
|
|
): Request {
|
|
return new Request([], [], [], $cookies, [
|
|
'HTTP_X_CSRF_TOKEN' => $csrf,
|
|
'HTTP_X_TURN_TOKEN' => $turnToken,
|
|
'__csrf_secret' => self::SECRET,
|
|
'CONTENT_TYPE' => 'application/json',
|
|
], '', 'POST', '/matches/current/test', 'application/json', json_encode($body, JSON_THROW_ON_ERROR));
|
|
}
|
|
}
|