AbstractSmrPlayerIntegrationTest::test_UnderAttack() - Code Metrics - Inspection of "SmrPlayer: simplify removeUnderAttack" - smrealms/smr - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#1474)

by Dan

created 2022-11-22 16:54 UTC

test_UnderAttack() A

↳ Parent: AbstractSmrPlayerIntegrationTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	8
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	17
rs	10

<?php declare(strict_types=1);

namespace SmrTest\lib\DefaultGame;

use AbstractSmrPlayer;
use Smr\Exceptions\PlayerNotFound;
use Smr\Exceptions\UserError;
use SmrTest\BaseIntegrationSpec;

/**
 * @covers AbstractSmrPlayer
 */
class AbstractSmrPlayerIntegrationTest extends BaseIntegrationSpec {

	protected function tablesToTruncate(): array {
		return ['player'];
	}

	protected function tearDown(): void {
		AbstractSmrPlayer::clearCache();
	}

	public function test_createPlayer(): void {
		// Test arbitrary input
		$accountID = 2;
		$gameID = 42;
		$name = 'test';
		$raceID = RACE_HUMAN;
		$isNewbie = true;
		$isNpc = false;

		$player = AbstractSmrPlayer::createPlayer($accountID, $gameID, $name, $raceID, $isNewbie, $isNpc);

		$this->assertSame($accountID, $player->getAccountID());
		$this->assertSame($gameID, $player->getGameID());
		$this->assertSame($name, $player->getPlayerName());
		$this->assertSame($raceID, $player->getRaceID());
		$this->assertSame($isNewbie, $player->hasNewbieStatus());
		$this->assertSame($isNpc, $player->isNPC());
		$this->assertSame(1, $player->getSectorID());
		$this->assertSame(1, $player->getPlayerID());
	}

	public function test_createPlayer_duplicate_name(): void {
		$name = 'test';
		AbstractSmrPlayer::createPlayer(1, 1, $name, RACE_HUMAN, false);
		$this->expectException(UserError::class);
		$this->expectExceptionMessage('That player name already exists.');
		AbstractSmrPlayer::createPlayer(2, 1, $name, RACE_HUMAN, false);
	}

	public function test_createPlayer_increment_playerid(): void {
		AbstractSmrPlayer::createPlayer(1, 1, 'test1', RACE_HUMAN, false);
		$player = AbstractSmrPlayer::createPlayer(2, 1, 'test2', RACE_HUMAN, false);
		$this->assertSame(2, $player->getPlayerID());
	}

	public function test_getPlayer_returns_created_player(): void {
		// Given a player that is created
		$player1 = AbstractSmrPlayer::createPlayer(1, 2, 'test1', RACE_HUMAN, false);
		// When we get the same player
		$player2 = AbstractSmrPlayer::getPlayer(1, 2);
		// Then they should be the same object
		self::assertSame($player1, $player2);

		// When we get the same player forcing a re-query from the database
		$player3 = AbstractSmrPlayer::getPlayer(1, 2, true);
		// Then they are not the same, but they are equal
		self::assertNotSame($player1, $player3);
		self::assertTrue($player1->equals($player3));
	}

	public function test_getPlayer_throws_when_no_record_found(): void {
		$this->expectException(PlayerNotFound::class);
		$this->expectExceptionMessage('Invalid accountID: 123 OR gameID: 321');
		AbstractSmrPlayer::getPlayer(123, 321);
	}

	public function test_changePlayerName_throws_when_name_unchanged(): void {
		// Try changing name to the same name
		$name = 'test';
		$player = AbstractSmrPlayer::createPlayer(1, 2, $name, RACE_HUMAN, false);
		$this->expectException(UserError::class);
		$this->expectExceptionMessage('Your player already has that name!');
		$player->changePlayerName($name);
	}

	public function test_changePlayerName_throws_when_name_is_in_use(): void {
		// Try changing name to a name that is already taken
		$name1 = 'test1';
		AbstractSmrPlayer::createPlayer(1, 2, $name1, RACE_HUMAN, false);
		$player2 = AbstractSmrPlayer::createPlayer(2, 2, 'test2', RACE_HUMAN, false);
		$this->expectException(UserError::class);
		$this->expectExceptionMessage('That name is already being used in this game!');
		$player2->changePlayerName($name1);
	}

	public function test_changePlayerName_allows_case_change(): void {
		// Try changing name from 'test' to 'TEST'
		$name = 'test';
		$player = AbstractSmrPlayer::createPlayer(1, 2, $name, RACE_HUMAN, false);
		$newName = strtoupper($name);
		self::assertNotEquals($name, $newName); // sanity check
		$player->changePlayerName($newName);
		self::assertSame($newName, $player->getPlayerName());
	}

	public function test_changePlayerName(): void {
		// Try changing name from 'test' to 'Wall-E' (as an admin)
		$player = AbstractSmrPlayer::createPlayer(1, 2, 'test', RACE_HUMAN, false);
		$player->changePlayerName('Wall-E');
		self::assertSame('Wall-E', $player->getPlayerName());
		// Make sure we have NOT used the name change token
		self::assertFalse($player->isNameChanged());
	}

	public function test_changePlayerNameByPlayer(): void {
		// Try changing name from 'test' to 'Wall-E' (as a player)
		$player = AbstractSmrPlayer::createPlayer(1, 2, 'test', RACE_HUMAN, false);
		$player->changePlayerNameByPlayer('Wall-E');
		self::assertSame('Wall-E', $player->getPlayerName());
		// Make sure we *have* used the name change token
		self::assertTrue($player->isNameChanged());
	}

	/**
	 * @dataProvider dataProvider_alignment
	 */
	public function test_alignment(int $alignment, bool $isGood, bool $isEvil, bool $isNeutral): void {
		// Create a player with a specific alignment
		$player = AbstractSmrPlayer::createPlayer(1, 1, 'test', RACE_HUMAN, false);
		$player->setAlignment($alignment);

		// Test the alignment querying methods
		self::assertSame($alignment, $player->getAlignment());
		self::assertSame($isGood, $player->hasGoodAlignment());
		self::assertSame($isEvil, $player->hasEvilAlignment());
		self::assertSame($isNeutral, $player->hasNeutralAlignment());
	}

	/**
	 * @return array<array{int, bool, bool, bool}>

	 */
	public function dataProvider_alignment(): array {
		// Test at, above, and below alignment thresholds
		return [
			[0, false, false, true],
			[ALIGNMENT_GOOD, true, false, false],
			[ALIGNMENT_GOOD + 1, true, false, false],
			[ALIGNMENT_GOOD - 1, false, false, true],
			[ALIGNMENT_EVIL, false, true, false],
			[ALIGNMENT_EVIL + 1, false, false, true],
			[ALIGNMENT_EVIL - 1, false, true, false],
		];
	}

	public function test_UnderAttack(): void {
		$player = AbstractSmrPlayer::createPlayer(1, 1, 'test', RACE_HUMAN, false);

		// Not under attack by default
		self::assertFalse($player->isUnderAttack());

		// Value is changed by setting it
		$player->setUnderAttack(true);
		self::assertTrue($player->isUnderAttack());

		// Value is not set to false on ajax page loads
		self::assertTrue($player->removeUnderAttack(ajax: true));
		self::assertTrue($player->isUnderAttack());

		// Value is set to false on non-ajax page loads
		self::assertTrue($player->removeUnderAttack(ajax: false));
		self::assertFalse($player->isUnderAttack());
	}

}


1			<?php declare(strict_types=1);
2
3			namespace SmrTest\lib\DefaultGame;
4
5			use AbstractSmrPlayer;
6			use Smr\Exceptions\PlayerNotFound;
7			use Smr\Exceptions\UserError;
8			use SmrTest\BaseIntegrationSpec;
9
10			/**
11			* @covers AbstractSmrPlayer
12			*/
13			class AbstractSmrPlayerIntegrationTest extends BaseIntegrationSpec {
14
15			protected function tablesToTruncate(): array {
16			return ['player'];
17			}
18
19			protected function tearDown(): void {
20			AbstractSmrPlayer::clearCache();
21			}
22
23			public function test_createPlayer(): void {
24			// Test arbitrary input
25			$accountID = 2;
26			$gameID = 42;
27			$name = 'test';
28			$raceID = RACE_HUMAN;
29			$isNewbie = true;
30			$isNpc = false;
31
32			$player = AbstractSmrPlayer::createPlayer($accountID, $gameID, $name, $raceID, $isNewbie, $isNpc);
33
34			$this->assertSame($accountID, $player->getAccountID());
35			$this->assertSame($gameID, $player->getGameID());
36			$this->assertSame($name, $player->getPlayerName());
37			$this->assertSame($raceID, $player->getRaceID());
38			$this->assertSame($isNewbie, $player->hasNewbieStatus());
39			$this->assertSame($isNpc, $player->isNPC());
40			$this->assertSame(1, $player->getSectorID());
41			$this->assertSame(1, $player->getPlayerID());
42			}
43
44			public function test_createPlayer_duplicate_name(): void {
45			$name = 'test';
46			AbstractSmrPlayer::createPlayer(1, 1, $name, RACE_HUMAN, false);
47			$this->expectException(UserError::class);
48			$this->expectExceptionMessage('That player name already exists.');
49			AbstractSmrPlayer::createPlayer(2, 1, $name, RACE_HUMAN, false);
50			}
51
52			public function test_createPlayer_increment_playerid(): void {
53			AbstractSmrPlayer::createPlayer(1, 1, 'test1', RACE_HUMAN, false);
54			$player = AbstractSmrPlayer::createPlayer(2, 1, 'test2', RACE_HUMAN, false);
55			$this->assertSame(2, $player->getPlayerID());
56			}
57
58			public function test_getPlayer_returns_created_player(): void {
59			// Given a player that is created
60			$player1 = AbstractSmrPlayer::createPlayer(1, 2, 'test1', RACE_HUMAN, false);
61			// When we get the same player
62			$player2 = AbstractSmrPlayer::getPlayer(1, 2);
63			// Then they should be the same object
64			self::assertSame($player1, $player2);
65
66			// When we get the same player forcing a re-query from the database
67			$player3 = AbstractSmrPlayer::getPlayer(1, 2, true);
68			// Then they are not the same, but they are equal
69			self::assertNotSame($player1, $player3);
70			self::assertTrue($player1->equals($player3));
71			}
72
73			public function test_getPlayer_throws_when_no_record_found(): void {
74			$this->expectException(PlayerNotFound::class);
75			$this->expectExceptionMessage('Invalid accountID: 123 OR gameID: 321');
76			AbstractSmrPlayer::getPlayer(123, 321);
77			}
78
79			public function test_changePlayerName_throws_when_name_unchanged(): void {
80			// Try changing name to the same name
81			$name = 'test';
82			$player = AbstractSmrPlayer::createPlayer(1, 2, $name, RACE_HUMAN, false);
83			$this->expectException(UserError::class);
84			$this->expectExceptionMessage('Your player already has that name!');
85			$player->changePlayerName($name);
86			}
87
88			public function test_changePlayerName_throws_when_name_is_in_use(): void {
89			// Try changing name to a name that is already taken
90			$name1 = 'test1';
91			AbstractSmrPlayer::createPlayer(1, 2, $name1, RACE_HUMAN, false);
92			$player2 = AbstractSmrPlayer::createPlayer(2, 2, 'test2', RACE_HUMAN, false);
93			$this->expectException(UserError::class);
94			$this->expectExceptionMessage('That name is already being used in this game!');
95			$player2->changePlayerName($name1);
96			}
97
98			public function test_changePlayerName_allows_case_change(): void {
99			// Try changing name from 'test' to 'TEST'
100			$name = 'test';
101			$player = AbstractSmrPlayer::createPlayer(1, 2, $name, RACE_HUMAN, false);
102			$newName = strtoupper($name);
103			self::assertNotEquals($name, $newName); // sanity check
104			$player->changePlayerName($newName);
105			self::assertSame($newName, $player->getPlayerName());
106			}
107
108			public function test_changePlayerName(): void {
109			// Try changing name from 'test' to 'Wall-E' (as an admin)
110			$player = AbstractSmrPlayer::createPlayer(1, 2, 'test', RACE_HUMAN, false);
111			$player->changePlayerName('Wall-E');
112			self::assertSame('Wall-E', $player->getPlayerName());
113			// Make sure we have NOT used the name change token
114			self::assertFalse($player->isNameChanged());
115			}
116
117			public function test_changePlayerNameByPlayer(): void {
118			// Try changing name from 'test' to 'Wall-E' (as a player)
119			$player = AbstractSmrPlayer::createPlayer(1, 2, 'test', RACE_HUMAN, false);
120			$player->changePlayerNameByPlayer('Wall-E');
121			self::assertSame('Wall-E', $player->getPlayerName());
122			// Make sure we have used the name change token
123			self::assertTrue($player->isNameChanged());
124			}
125
126			/**
127			* @dataProvider dataProvider_alignment
128			*/
129			public function test_alignment(int $alignment, bool $isGood, bool $isEvil, bool $isNeutral): void {
130			// Create a player with a specific alignment
131			$player = AbstractSmrPlayer::createPlayer(1, 1, 'test', RACE_HUMAN, false);
132			$player->setAlignment($alignment);
133
134			// Test the alignment querying methods
135			self::assertSame($alignment, $player->getAlignment());
136			self::assertSame($isGood, $player->hasGoodAlignment());
137			self::assertSame($isEvil, $player->hasEvilAlignment());
138			self::assertSame($isNeutral, $player->hasNeutralAlignment());
139			}
140
141			/**
142			* @return array<array{int, bool, bool, bool}>
			0 ignored issues – show Documentation Bug introduced 2022-07-03 19:56 UTC by Report Bug Copy Issue Report The doc comment `array<array{int, bool, bool, bool}>` at position `4` could not be parsed: Expected ':' at position 4, but found 'int'. Loading history...
143			*/
144			public function dataProvider_alignment(): array {
145			// Test at, above, and below alignment thresholds
146			return [
147			[0, false, false, true],
148			[ALIGNMENT_GOOD, true, false, false],
149			[ALIGNMENT_GOOD + 1, true, false, false],
150			[ALIGNMENT_GOOD - 1, false, false, true],
151			[ALIGNMENT_EVIL, false, true, false],
152			[ALIGNMENT_EVIL + 1, false, false, true],
153			[ALIGNMENT_EVIL - 1, false, true, false],
154			];
155			}
156
157			public function test_UnderAttack(): void {
158			$player = AbstractSmrPlayer::createPlayer(1, 1, 'test', RACE_HUMAN, false);
159
160			// Not under attack by default
161			self::assertFalse($player->isUnderAttack());
162
163			// Value is changed by setting it
164			$player->setUnderAttack(true);
165			self::assertTrue($player->isUnderAttack());
166
167			// Value is not set to false on ajax page loads
168			self::assertTrue($player->removeUnderAttack(ajax: true));
169			self::assertTrue($player->isUnderAttack());
170
171			// Value is set to false on non-ajax page loads
172			self::assertTrue($player->removeUnderAttack(ajax: false));
173			self::assertFalse($player->isUnderAttack());
174			}
175
176			}
177

smrealms / smr

Scrutinizer GitHub App not installed

Pull Request — main (#1474)

test_UnderAttack() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like