SmrPlanetIntegrationTest::test_owner() - Code Metrics - Inspection of "Improvements to SmrPlanet" - smrealms/smr - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1014)

by Dan

created 2021-03-07 09:16 UTC

SmrPlanetIntegrationTest::test_owner() A

↳ Parent: SmrPlanetIntegrationTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	16
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	10
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	16
rs	9.9332

<?php declare(strict_types=1);

namespace SmrTest\lib\DefaultGame;

use SmrPlanet;
use SmrTest\BaseIntegrationSpec;

require_once(LIB . 'Default/smr.inc.php');

/**
 * Class SmrPlanetIntegrationTest
 * @covers SmrPlanet
 */
class SmrPlanetIntegrationTest extends BaseIntegrationSpec {

	protected function tearDown() : void {
		SmrPlanet::clearCache();
		parent::tearDown();
	}

	public function test_createPlanet() : void {
		// Test arbitrary input
		$sectorID = 2;
		$gameID = 42;
		$typeID = 3;
		$inhabitableTime = 5;

		$planet = SmrPlanet::createPlanet($gameID, $sectorID, $typeID, $inhabitableTime);
		$this->assertTrue($planet->exists());

		// Check properties set explicitly
		$this->assertSame($gameID, $planet->getGameID());
		$this->assertSame($sectorID, $planet->getSectorID());
		$this->assertSame($typeID, $planet->getTypeID());
		$this->assertSame($inhabitableTime, $planet->getInhabitableTime());
	}

	public function test_createPlanet_already_exists() : void {
		SmrPlanet::createPlanet(1, 1, 1, 1);
		$this->expectException(\Exception::class);
		$this->expectExceptionMessage('Planet already exists');
		SmrPlanet::createPlanet(1, 1, 1, 1);
	}

	public function test_removePlanet() : void {
		// Check that planet exists
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
		$this->assertTrue($planet->exists());

		SmrPlanet::removePlanet(1, 1);
		$planet = SmrPlanet::getPlanet(1, 1, true);
		$this->assertFalse($planet->exists());
	}

	public function test_name() : void {
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
		// Check default name
		$this->assertSame('Unknown', $planet->getDisplayName());

		// Set a new name (include non-HTML-safe character)
		$planet->setName('Test&');
		$this->assertSame('Test&amp;', $planet->getDisplayName());
	}

	public function test_owner() : void {
		// Check default owner
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
		$this->assertFalse($planet->hasOwner());
		$this->assertSame(0, $planet->getOwnerID());

		// Set a new owner
		$ownerID = 3;
		$planet->setOwnerID($ownerID);
		$this->assertTrue($planet->hasOwner());
		$this->assertSame($ownerID, $planet->getOwnerID());

		// Remove the owner again
		$planet->removeOwner();
		$this->assertFalse($planet->hasOwner());
		$this->assertSame(0, $planet->getOwnerID());
	}

	public function test_password() : void {
		// Check default password
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
		$this->assertSame('', $planet->getPassword());

		// Set a new password
		$password = 'test';
		$planet->setPassword($password);
		$this->assertSame($password, $planet->getPassword());

		// Remove the password again
		$planet->removePassword();
		$this->assertSame('', $planet->getPassword());
	}

	public function test_credits() : void {
		// Check default credits
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
		$this->assertSame(0, $planet->getCredits());

		// Check increase/decrease credits
		$planet->increaseCredits(100);
		$this->assertSame(100, $planet->getCredits());
		$planet->increaseCredits(50);
		$this->assertSame(150, $planet->getCredits());
		$planet->decreaseCredits(50);
		$this->assertSame(100, $planet->getCredits());
	}

	public function test_bonds() : void {
		// Check default bond
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
		$this->assertSame(0, $planet->getBonds());

		// Check increase/decrease bonds
		$planet->increaseBonds(100);
		$this->assertSame(100, $planet->getBonds());
		$planet->increaseBonds(50);
		$this->assertSame(150, $planet->getBonds());
		$planet->decreaseBonds(50);
		$this->assertSame(100, $planet->getBonds());
	}

	public function test_bond_maturity() : void {
		// Check default maturity
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
		$this->assertSame(0, $planet->getMaturity());

		// Set a new bond maturity
		$maturity = time();
		$planet->setMaturity($maturity);
		$this->assertSame($maturity, $planet->getMaturity());
	}

	public function test_stockpile() : void {
		// Check default stockpile
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
		$this->assertFalse($planet->hasStockpile());
		$this->assertSame([], $planet->getStockpile());
		foreach (array_keys(\Globals::getGoods()) as $goodID) {
			$this->assertFalse($planet->hasStockpile($goodID));
			$this->assertSame(0, $planet->getStockpile($goodID));
		}

		// Setting 0 still counts as empty
		$planet->setStockpile(GOODS_ORE, 0);
		$this->assertFalse($planet->hasStockpile());
		$this->assertFalse($planet->hasStockpile(GOODS_ORE));

		// Check increase stockpile
		$planet->increaseStockpile(GOODS_ORE, 50);
		$this->assertTrue($planet->hasStockpile());
		$this->assertSame([GOODS_ORE => 50], $planet->getStockpile());
		foreach (array_keys(\Globals::getGoods()) as $goodID) {
			if ($goodID === GOODS_ORE) {
				$this->assertTrue($planet->hasStockpile($goodID));
				$this->assertSame(50, $planet->getStockpile($goodID));
			} else {
				$this->assertFalse($planet->hasStockpile($goodID));
				$this->assertSame(0, $planet->getStockpile($goodID));
			}
		}

		// Check decrease stockpile
		$planet->decreaseStockpile(GOODS_ORE, 10);
		$this->assertTrue($planet->hasStockpile());
		$this->assertSame([GOODS_ORE => 40], $planet->getStockpile());
		foreach (array_keys(\Globals::getGoods()) as $goodID) {
			if ($goodID === GOODS_ORE) {
				$this->assertTrue($planet->hasStockpile($goodID));
				$this->assertSame(40, $planet->getStockpile($goodID));
			} else {
				$this->assertFalse($planet->hasStockpile($goodID));
				$this->assertSame(0, $planet->getStockpile($goodID));
			}
		}

		// Check remaining stockpile (ore: 600 - 40)
		$this->assertSame(560, $planet->getRemainingStockpile(GOODS_ORE));
	}

	public function test_setStockpile_throws_when_negative() : void {
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
		$this->expectException(\Exception::class);
		$this->expectExceptionMessage('Trying to set negative stockpile');
		$planet->setStockpile(GOODS_ORE, -20);
	}

	public function test_setBuilding_throws_when_negative() : void {
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
		$this->expectException(\Exception::class);
		$this->expectExceptionMessage('Cannot set negative number of buildings');
		$planet->setBuilding(PLANET_HANGAR, -1);
	}

	public function test_destroyBuilding_throws_when_invalid() : void {
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
		$this->expectException(\Exception::class);
		$this->expectExceptionMessage('Cannot set negative number of buildings');
		$planet->destroyBuilding(PLANET_TURRET, 1);
	}

	public function test_checkForDowngrade() : void {
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);

		// If we don't do enough damage, we should never downgrade
		$this->assertSame([], $planet->checkForDowngrade(0));

		// With no buildings, this should always return empty
		$this->assertSame([], $planet->checkForDowngrade(100 * SmrPlanet::DAMAGE_NEEDED_FOR_DOWNGRADE_CHANCE));

		// Give the planet 2 structures, and destroy them both
		$planet->setBuilding(PLANET_GENERATOR, 2);
		srand(95); // seed rand for reproducibility
		$result = $planet->checkForDowngrade(2 * SmrPlanet::DAMAGE_NEEDED_FOR_DOWNGRADE_CHANCE);
		$this->assertSame([PLANET_GENERATOR => 2], $result);
	}

	public function test_buildings() : void {
		$planet = SmrPlanet::createPlanet(1, 1, 1, 1);

		// Tests with no buildings
		$this->assertFalse($planet->hasBuilding(PLANET_HANGAR));
		$this->assertSame(0, $planet->getBuilding(PLANET_HANGAR));
		$this->assertSame(0.0, $planet->getLevel());

		// Add some hangars
		$planet->increaseBuilding(PLANET_HANGAR, 4);
		$this->assertTrue($planet->hasBuilding(PLANET_HANGAR));
		$this->assertSame(4, $planet->getBuilding(PLANET_HANGAR));
		$this->assertSame(4/3, $planet->getLevel());

		// Destroy some hangars
		$planet->destroyBuilding(PLANET_HANGAR, 2);
		$this->assertTrue($planet->hasBuilding(PLANET_HANGAR));
		$this->assertSame(2, $planet->getBuilding(PLANET_HANGAR));
		$this->assertSame(2/3, $planet->getLevel());
	}

}


1			<?php declare(strict_types=1);
2
3			namespace SmrTest\lib\DefaultGame;
4
5			use SmrPlanet;
6			use SmrTest\BaseIntegrationSpec;
7
8			require_once(LIB . 'Default/smr.inc.php');
9
10			/**
11			* Class SmrPlanetIntegrationTest
12			* @covers SmrPlanet
13			*/
14			class SmrPlanetIntegrationTest extends BaseIntegrationSpec {
15
16			protected function tearDown() : void {
17			SmrPlanet::clearCache();
18			parent::tearDown();
19			}
20
21			public function test_createPlanet() : void {
22			// Test arbitrary input
23			$sectorID = 2;
24			$gameID = 42;
25			$typeID = 3;
26			$inhabitableTime = 5;
27
28			$planet = SmrPlanet::createPlanet($gameID, $sectorID, $typeID, $inhabitableTime);
29			$this->assertTrue($planet->exists());
30
31			// Check properties set explicitly
32			$this->assertSame($gameID, $planet->getGameID());
33			$this->assertSame($sectorID, $planet->getSectorID());
34			$this->assertSame($typeID, $planet->getTypeID());
35			$this->assertSame($inhabitableTime, $planet->getInhabitableTime());
36			}
37
38			public function test_createPlanet_already_exists() : void {
39			SmrPlanet::createPlanet(1, 1, 1, 1);
40			$this->expectException(\Exception::class);
41			$this->expectExceptionMessage('Planet already exists');
42			SmrPlanet::createPlanet(1, 1, 1, 1);
43			}
44
45			public function test_removePlanet() : void {
46			// Check that planet exists
47			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
48			$this->assertTrue($planet->exists());
49
50			SmrPlanet::removePlanet(1, 1);
51			$planet = SmrPlanet::getPlanet(1, 1, true);
52			$this->assertFalse($planet->exists());
53			}
54
55			public function test_name() : void {
56			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
57			// Check default name
58			$this->assertSame('Unknown', $planet->getDisplayName());
59
60			// Set a new name (include non-HTML-safe character)
61			$planet->setName('Test&');
62			$this->assertSame('Test&', $planet->getDisplayName());
63			}
64
65			public function test_owner() : void {
66			// Check default owner
67			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
68			$this->assertFalse($planet->hasOwner());
69			$this->assertSame(0, $planet->getOwnerID());
70
71			// Set a new owner
72			$ownerID = 3;
73			$planet->setOwnerID($ownerID);
74			$this->assertTrue($planet->hasOwner());
75			$this->assertSame($ownerID, $planet->getOwnerID());
76
77			// Remove the owner again
78			$planet->removeOwner();
79			$this->assertFalse($planet->hasOwner());
80			$this->assertSame(0, $planet->getOwnerID());
81			}
82
83			public function test_password() : void {
84			// Check default password
85			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
86			$this->assertSame('', $planet->getPassword());
87
88			// Set a new password
89			$password = 'test';
90			$planet->setPassword($password);
91			$this->assertSame($password, $planet->getPassword());
92
93			// Remove the password again
94			$planet->removePassword();
95			$this->assertSame('', $planet->getPassword());
96			}
97
98			public function test_credits() : void {
99			// Check default credits
100			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
101			$this->assertSame(0, $planet->getCredits());
102
103			// Check increase/decrease credits
104			$planet->increaseCredits(100);
105			$this->assertSame(100, $planet->getCredits());
106			$planet->increaseCredits(50);
107			$this->assertSame(150, $planet->getCredits());
108			$planet->decreaseCredits(50);
109			$this->assertSame(100, $planet->getCredits());
110			}
111
112			public function test_bonds() : void {
113			// Check default bond
114			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
115			$this->assertSame(0, $planet->getBonds());
116
117			// Check increase/decrease bonds
118			$planet->increaseBonds(100);
119			$this->assertSame(100, $planet->getBonds());
120			$planet->increaseBonds(50);
121			$this->assertSame(150, $planet->getBonds());
122			$planet->decreaseBonds(50);
123			$this->assertSame(100, $planet->getBonds());
124			}
125
126			public function test_bond_maturity() : void {
127			// Check default maturity
128			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
129			$this->assertSame(0, $planet->getMaturity());
130
131			// Set a new bond maturity
132			$maturity = time();
133			$planet->setMaturity($maturity);
134			$this->assertSame($maturity, $planet->getMaturity());
135			}
136
137			public function test_stockpile() : void {
138			// Check default stockpile
139			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
140			$this->assertFalse($planet->hasStockpile());
141			$this->assertSame([], $planet->getStockpile());
142			foreach (array_keys(\Globals::getGoods()) as $goodID) {
143			$this->assertFalse($planet->hasStockpile($goodID));
144			$this->assertSame(0, $planet->getStockpile($goodID));
145			}
146
147			// Setting 0 still counts as empty
148			$planet->setStockpile(GOODS_ORE, 0);
149			$this->assertFalse($planet->hasStockpile());
150			$this->assertFalse($planet->hasStockpile(GOODS_ORE));
151
152			// Check increase stockpile
153			$planet->increaseStockpile(GOODS_ORE, 50);
154			$this->assertTrue($planet->hasStockpile());
155			$this->assertSame([GOODS_ORE => 50], $planet->getStockpile());
156			foreach (array_keys(\Globals::getGoods()) as $goodID) {
157			if ($goodID === GOODS_ORE) {
158			$this->assertTrue($planet->hasStockpile($goodID));
159			$this->assertSame(50, $planet->getStockpile($goodID));
160			} else {
161			$this->assertFalse($planet->hasStockpile($goodID));
162			$this->assertSame(0, $planet->getStockpile($goodID));
163			}
164			}
165
166			// Check decrease stockpile
167			$planet->decreaseStockpile(GOODS_ORE, 10);
168			$this->assertTrue($planet->hasStockpile());
169			$this->assertSame([GOODS_ORE => 40], $planet->getStockpile());
170			foreach (array_keys(\Globals::getGoods()) as $goodID) {
171			if ($goodID === GOODS_ORE) {
172			$this->assertTrue($planet->hasStockpile($goodID));
173			$this->assertSame(40, $planet->getStockpile($goodID));
174			} else {
175			$this->assertFalse($planet->hasStockpile($goodID));
176			$this->assertSame(0, $planet->getStockpile($goodID));
177			}
178			}
179
180			// Check remaining stockpile (ore: 600 - 40)
181			$this->assertSame(560, $planet->getRemainingStockpile(GOODS_ORE));
182			}
183
184			public function test_setStockpile_throws_when_negative() : void {
185			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
186			$this->expectException(\Exception::class);
187			$this->expectExceptionMessage('Trying to set negative stockpile');
188			$planet->setStockpile(GOODS_ORE, -20);
189			}
190
191			public function test_setBuilding_throws_when_negative() : void {
192			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
193			$this->expectException(\Exception::class);
194			$this->expectExceptionMessage('Cannot set negative number of buildings');
195			$planet->setBuilding(PLANET_HANGAR, -1);
196			}
197
198			public function test_destroyBuilding_throws_when_invalid() : void {
199			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
200			$this->expectException(\Exception::class);
201			$this->expectExceptionMessage('Cannot set negative number of buildings');
202			$planet->destroyBuilding(PLANET_TURRET, 1);
203			}
204
205			public function test_checkForDowngrade() : void {
206			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
207
208			// If we don't do enough damage, we should never downgrade
209			$this->assertSame([], $planet->checkForDowngrade(0));
210
211			// With no buildings, this should always return empty
212			$this->assertSame([], $planet->checkForDowngrade(100 * SmrPlanet::DAMAGE_NEEDED_FOR_DOWNGRADE_CHANCE));
213
214			// Give the planet 2 structures, and destroy them both
215			$planet->setBuilding(PLANET_GENERATOR, 2);
216			srand(95); // seed rand for reproducibility
217			$result = $planet->checkForDowngrade(2 * SmrPlanet::DAMAGE_NEEDED_FOR_DOWNGRADE_CHANCE);
218			$this->assertSame([PLANET_GENERATOR => 2], $result);
219			}
220
221			public function test_buildings() : void {
222			$planet = SmrPlanet::createPlanet(1, 1, 1, 1);
223
224			// Tests with no buildings
225			$this->assertFalse($planet->hasBuilding(PLANET_HANGAR));
226			$this->assertSame(0, $planet->getBuilding(PLANET_HANGAR));
227			$this->assertSame(0.0, $planet->getLevel());
228
229			// Add some hangars
230			$planet->increaseBuilding(PLANET_HANGAR, 4);
231			$this->assertTrue($planet->hasBuilding(PLANET_HANGAR));
232			$this->assertSame(4, $planet->getBuilding(PLANET_HANGAR));
233			$this->assertSame(4/3, $planet->getLevel());
234
235			// Destroy some hangars
236			$planet->destroyBuilding(PLANET_HANGAR, 2);
237			$this->assertTrue($planet->hasBuilding(PLANET_HANGAR));
238			$this->assertSame(2, $planet->getBuilding(PLANET_HANGAR));
239			$this->assertSame(2/3, $planet->getLevel());
240			}
241
242			}
243

smrealms / smr

Scrutinizer GitHub App not installed

Pull Request — master (#1014)

SmrPlanetIntegrationTest::test_owner() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like