async def test_transfer_success_case(self):
await self.system_clock_fast_forward(speed_multiplier=25)
commutator, error = await self.login('player', "127.0.0.1")
self.assertIsNotNone(commutator)
self.assertIsNone(error)
miner_1 = modules.get_ship(commutator, ShipType.MINER.value, "miner-1")
self.assertIsNotNone(miner_1)
miner_1_cargo = modules.get_cargo(commutator=miner_1, name='cargo')
self.assertIsNotNone(miner_1_cargo)
miner_2 = modules.get_ship(commutator, ShipType.MINER.value, "miner-2")
self.assertIsNotNone(miner_2)
miner_2_cargo = modules.get_cargo(commutator=miner_2, name='cargo')
self.assertIsNotNone(miner_2_cargo)
# Opening a port on miner_2
access_key = 12456
status, port = await miner_2_cargo.open_port(access_key=access_key)
self.assertTrue(status.is_success())
self.assertNotEqual(0, port)
total_transferred_amount: float = 0.0 # Will be accumulated in progress callback
def cb_progress_report(item: ResourceItem):
self.assertEqual(ResourceType.e_METALS, item.resource_type)
nonlocal total_transferred_amount
total_transferred_amount += item.amount
# Transferring resources from miner_1 to miner_2
status = await miner_1_cargo.transfer(port=port,
access_key=access_key,
progress_cb=cb_progress_report,
resource=ResourceItem(
ResourceType.e_METALS,
30000))
self.assertEqual(ResourceContainerI.Status.SUCCESS, status)
self.assertAlmostEqual(30000, total_transferred_amount)
# Check resources in containers
content = await miner_1_cargo.get_content()
self.assertAlmostEqual(20000, content.resources[ResourceType.e_METALS])
self.assertAlmostEqual(20000,
content.resources[ResourceType.e_SILICATES])
self.assertAlmostEqual(15000, content.resources[ResourceType.e_ICE])
content = await miner_2_cargo.get_content()
self.assertAlmostEqual(35000, content.resources[ResourceType.e_METALS])
self.assertAlmostEqual(5000,
content.resources[ResourceType.e_SILICATES])
self.assertAlmostEqual(10000, content.resources[ResourceType.e_ICE])
async def test_mining(self):
await self.system_clock_fast_forward(speed_multiplier=50)
commutator, error = await self.login('oreman', "127.0.0.1")
self.assertIsNotNone(commutator)
self.assertIsNone(error)
miner_ship = modules.get_ship(commutator, "Miner", "miner-1")
self.assertIsNotNone(miner_ship)
miner = modules.get_asteroid_miner(miner_ship, "miner")
self.assertIsNotNone(miner)
status = await miner.bind_to_cargo("cargo")
self.assertEqual(AsteroidMinerI.Status.SUCCESS, status)
self.assertEqual("cargo", miner.cargo_name)
# Looking for the asteroid, that should be nearby
scanner: modules.CelestialScanner = modules.get_celestial_scanner(
miner_ship, "scanner")
self.assertIsNotNone(scanner)
result, error = await scanner.scan_sync(scanning_radius_km=1,
minimal_radius_m=5)
self.assertIsNone(error)
self.assertIsNotNone(result)
self.assertEqual(1, len(result))
asteroid = result[0]
# Mining until we have 1000 of metals
collected_resources: Dict[ResourceType, float] = {
ResourceType.e_METALS: 0
}
def progress_cb(status: AsteroidMinerI.Status,
resources: ResourcesDict) -> bool:
for resource_type, amount in resources.items():
if resource_type in collected_resources:
collected_resources[resource_type] += amount
else:
collected_resources[resource_type] = amount
return collected_resources[ResourceType.e_METALS] < 1000
# Mining an asteroid
await self.system_clock_fast_forward(speed_multiplier=500)
status = await miner.start_mining(asteroid_id=asteroid.object_id,
progress_cb=progress_cb)
self.assertEqual(AsteroidMinerI.Status.SUCCESS, status)
await self.system_clock_fast_forward(speed_multiplier=50)
# Check the cargo content
cargo = modules.get_cargo(miner_ship, "cargo")
self.assertIsNotNone(cargo)
content = await cargo.get_content()
self.assertIsNotNone(content)
self.assertLessEqual(1000, content.resources[ResourceType.e_METALS])
async def test_transfer_fails_cases(self):
await self.system_clock_fast_forward(speed_multiplier=25)
commutator, error = await self.login('player', "127.0.0.1")
self.assertIsNotNone(commutator)
self.assertIsNone(error)
miner_1 = modules.get_ship(commutator, ShipType.MINER.value, "miner-1")
self.assertIsNotNone(miner_1)
miner_1_cargo = modules.get_cargo(commutator=miner_1, name='cargo')
self.assertIsNotNone(miner_1_cargo)
miner_2 = modules.get_ship(commutator, ShipType.MINER.value, "miner-2")
self.assertIsNotNone(miner_2)
miner_2_cargo = modules.get_cargo(commutator=miner_2, name='cargo')
self.assertIsNotNone(miner_2_cargo)
# Port is not opened error:
status = await miner_1_cargo.transfer(port=4,
access_key=123456,
resource=ResourceItem(
ResourceType.e_METALS,
30000))
self.assertEqual(ResourceContainerI.Status.PORT_IS_NOT_OPENED, status)
# Opening a port on miner_2
access_key = 12456
status, port = await miner_2_cargo.open_port(access_key=access_key)
self.assertTrue(status.is_success())
self.assertNotEqual(0, port)
# Invalid access key
status = await miner_1_cargo.transfer(port=port,
access_key=access_key - 1,
resource=ResourceItem(
ResourceType.e_METALS,
30000))
self.assertEqual(ResourceContainerI.Status.INVALID_ACCESS_KEY, status)
async def test_cargo_is_full(self):
await self.system_clock_fast_forward(speed_multiplier=50)
commutator, error = await self.login('oreman', "127.0.0.1")
self.assertIsNotNone(commutator)
self.assertIsNone(error)
miner_ship = modules.get_ship(commutator, "Miner", "miner-1")
self.assertIsNotNone(miner_ship)
miner = modules.get_asteroid_miner(miner_ship, "miner")
self.assertIsNotNone(miner)
status, miner_spec = await miner.get_specification()
self.assertEqual(status, AsteroidMinerI.Status.SUCCESS)
self.assertIsNotNone(miner_spec)
status = await miner.bind_to_cargo("tiny_cargo")
self.assertEqual(AsteroidMinerI.Status.SUCCESS, status)
self.assertEqual("tiny_cargo", miner.cargo_name)
# Looking for the asteroid, that should be nearby
scanner: modules.CelestialScanner = modules.get_celestial_scanner(
miner_ship, "scanner")
self.assertIsNotNone(scanner)
result, error = await scanner.scan_sync(scanning_radius_km=1,
minimal_radius_m=5)
self.assertIsNone(error)
self.assertIsNotNone(result)
self.assertEqual(1, len(result))
asteroid = result[0]
# Mining an asteroid
def progress_cb(status: AsteroidMinerI.Status,
item: ResourceItem) -> bool:
return True
# This will take a long time
await self.system_clock_fast_forward(1000)
status = await miner.start_mining(asteroid_id=asteroid.object_id,
progress_cb=progress_cb)
self.assertEqual(AsteroidMinerI.Status.NO_SPACE_AVAILABLE, status)
# Check that cargo is full of ice
cargo = modules.get_cargo(miner_ship, "tiny_cargo")
self.assertIsNotNone(cargo)
content = await cargo.get_content()
self.assertIsNotNone(content)
self.assertAlmostEqual(content.volume, content.used)
async def test_get_content(self):
await self.system_clock_fast_forward(speed_multiplier=25)
commutator, error = await self.login('player', "127.0.0.1")
self.assertIsNotNone(commutator)
self.assertIsNone(error)
miner_1 = modules.get_ship(commutator, ShipType.MINER.value, "miner-1")
self.assertIsNotNone(miner_1)
cargo = modules.get_cargo(commutator=miner_1, name='cargo')
self.assertIsNotNone(cargo)
content = await cargo.get_content()
self.assertAlmostEqual(20000,
content.resources[ResourceType.e_SILICATES])
self.assertAlmostEqual(50000, content.resources[ResourceType.e_METALS])
self.assertAlmostEqual(15000, content.resources[ResourceType.e_ICE])
async def test_open_close_port(self):
await self.system_clock_fast_forward(speed_multiplier=25)
commutator, error = await self.login('player', "127.0.0.1")
self.assertIsNotNone(commutator)
self.assertIsNone(error)
miner_1 = modules.get_ship(commutator, ShipType.MINER.value, "miner-1")
self.assertIsNotNone(miner_1)
cargo = modules.get_cargo(commutator=miner_1, name='cargo')
self.assertIsNotNone(cargo)
self.assertIsNone(cargo.get_opened_port())
# Trying to close a port, that has not been opened
status = await cargo.close_port()
self.assertEqual(ResourceContainerI.Status.PORT_IS_NOT_OPENED, status)
# Opening a port
access_key = 12456
status, port = await cargo.open_port(access_key=access_key)
self.assertTrue(status.is_success())
self.assertNotEqual(0, port)
self.assertEqual(port, cargo.get_opened_port()[0])
self.assertEqual(access_key, cargo.get_opened_port()[1])
# Trying to open yet another port
status, port = await cargo.open_port(access_key=access_key * 2)
self.assertEqual(ResourceContainerI.Status.PORT_ALREADY_OPEN, status)
self.assertEqual(0, port)
# Closing port (twice)
status = await cargo.close_port()
self.assertEqual(ResourceContainerI.Status.SUCCESS, status)
status = await cargo.close_port()
self.assertEqual(ResourceContainerI.Status.PORT_IS_NOT_OPENED, status)
# Opening a port again
status, port = await cargo.open_port(access_key=access_key)
self.assertTrue(status.is_success())
self.assertNotEqual(0, port)
async def test_transfer_monitoring(self):
await self.system_clock_fast_forward(speed_multiplier=10)
commutator, error = await self.login('player', "127.0.0.1")
self.assertIsNotNone(commutator)
self.assertIsNone(error)
miner_1 = modules.get_ship(commutator, ShipType.MINER.value, "miner-1")
self.assertIsNotNone(miner_1)
miner_1_cargo = modules.get_cargo(commutator=miner_1, name='cargo')
self.assertIsNotNone(miner_1_cargo)
miner_2 = modules.get_ship(commutator, ShipType.MINER.value, "miner-2")
self.assertIsNotNone(miner_2)
miner_2_cargo = modules.get_cargo(commutator=miner_2, name='cargo')
self.assertIsNotNone(miner_2_cargo)
# Opening a port on miner_2
access_key = 12456
status, port = await miner_2_cargo.open_port(access_key=access_key)
self.assertTrue(status.is_success())
self.assertNotEqual(0, port)
# Will be collected during transferring
transactions: List[ResourceItem] = []
# Will be collected in monitoring tasks
miner_1_cargo_journal: List[ResourceContainerI.Content] = []
miner_2_cargo_journal: List[ResourceContainerI.Content] = []
async def do_monitoring(
container: modules.ResourceContainer,
journal: List[ResourceContainerI.Content]) \
-> ResourceContainerI.Status:
async for status, content in container.monitor():
if content:
journal.append(content)
else:
return status
return ResourceContainerI.Status.SUCCESS
miner_1_cargo_monitoring = asyncio.create_task(
do_monitoring(miner_1_cargo, miner_1_cargo_journal), )
miner_2_cargo_monitoring = asyncio.create_task(
do_monitoring(miner_2_cargo, miner_2_cargo_journal), )
status = await miner_1_cargo.transfer(port=port,
access_key=access_key,
progress_cb=transactions.append,
resource=ResourceItem(
ResourceType.e_METALS,
30000))
# Wait some additional time for monitoring events
await asyncio.sleep(0.2)
self.assertTrue(miner_1_cargo_monitoring.cancel())
self.assertTrue(miner_2_cargo_monitoring.cancel())
await asyncio.wait(
[miner_1_cargo_monitoring, miner_2_cargo_monitoring])
# Check that all data are consistent
self.assertEqual(len(miner_1_cargo_journal),
len(miner_2_cargo_journal))
self.assertEqual(len(miner_1_cargo_journal), len(transactions) + 1)
self.assertEqual(len(miner_2_cargo_journal), len(transactions) + 1)
current_content = miner_1_cargo_journal[0]
for updated_content, transaction in \
zip(miner_1_cargo_journal[1:], transactions):
resource_type = transaction.resource_type
amount = transaction.amount
self.assertAlmostEqual(
updated_content.resources[resource_type],
current_content.resources[resource_type] - amount)
current_content = updated_content
current_content = miner_2_cargo_journal[0]
for updated_content, transaction in \
zip(miner_2_cargo_journal[1:], transactions):
resource_type = transaction.resource_type
amount = transaction.amount
self.assertAlmostEqual(
updated_content.resources[resource_type],
current_content.resources[resource_type] + amount)
current_content = updated_content