def test_planes_post_multiple(self):
"""
Test adding a plane to a player multiple times
"""
shared_test_utils.create_table()
self.utils.create_player(player_id=self.player_name, balance=600)
result = self.http_client.post('/v1/planes',
json={
'plane': 'a0',
'city': 'c1001'
})
self.assertEqual({'balance': 400}, result.get_json())
self.assertEqual(201, result.status_code)
result = self.http_client.post('/v1/planes',
json={
'plane': 'a0',
'city': 'c1001'
})
self.assertEqual({'balance': 200}, result.get_json())
self.assertEqual(201, result.status_code)
# Query the table to validate the result
_, result = self.utils.get_player_attributes(
self.player_name, attributes_to_get=['planes'])
self.assertEqual(2, len(result['planes'].keys()))
def test_plane_load_jobs_wrong_job_type(self):
"""
Test loading a plane with wrong type of job
"""
shared_test_utils.create_table()
self.http_client.post('/v1/player')
self.http_client.post('/v1/planes',
json={
'plane': 'a1',
'city': 'c1002'
})
self.http_client.post('/v1/cities', json={'city': 'c1002'})
self.http_client.post('/v1/cities', json={'city': 'c1003'})
self.http_client.post('/v1/cities', json={'city': 'c1004'})
jobs = self.http_client.get('/v1/cities/c1002/jobs').get_json().get(
'jobs')
plane_id, _ = self.http_client.get('/v1/planes').get_json().get(
'planes').popitem()
# Pick some jobs of not compatible type
job_ids = [
key for key, values in jobs.items()
if values.get('job_type') == 'P'
][:5]
result = self.http_client.put(f'/v1/planes/{plane_id}/load',
json={'loaded_jobs': job_ids})
self.assertEqual(400, result.status_code)
self.assertEqual('Not enough capacity',
result.get_data().decode('utf-8'))
def test_planes_post_missing_arg(self):
"""
Test adding a plane to a player with missing parameters
"""
shared_test_utils.create_table()
result = self.http_client.post('/v1/planes')
self.assertEqual(400, result.status_code)
def test_add_jobs_to_plane(self):
"""
Test adding a jobs to a plane
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='foo', balance=100000)
self.utils.add_plane_to_player(player_id='foo',
plane_id='a1',
current_city_id='c1001')
self.utils.add_city_to_player(player_id='foo', city_id='c1001')
self.utils.add_city_to_player(player_id='foo', city_id='c1002')
self.utils.add_city_to_player(player_id='foo', city_id='c1003')
# Get the new cities and plane added to the player
_, result = self.utils.get_player_attributes(
player_id='foo', attributes_to_get=['cities', 'planes'])
plane_1_id, _ = result.get('planes').popitem()
player_cities = result.get('cities')
# Generate some random jobs
jobs = self.utils.generate_random_jobs(player_cities=player_cities,
current_city_id='c1001')
# Add the jobs to the plane
success, _ = self.utils.add_jobs_to_plane(player_id='foo',
plane_id=plane_1_id,
list_of_jobs=jobs)
self.assertTrue(success)
# Check the jobs added to the plane
_, result = self.utils.get_player_attributes(
player_id='foo', attributes_to_get=['planes'])
self.assertEqual(30, len(result['planes'][plane_1_id]['loaded_jobs']))
def test_cities_post_missing_body(self):
"""
Test creating a city when body is missing
"""
shared_test_utils.create_table()
result = self.http_client.post('/v1/cities')
self.assertEqual(400, result.status_code)
def test_remove_jobs_from_city(self):
"""
Test removing jobs from a city
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='foo', balance=100000)
self.utils.add_plane_to_player(player_id='foo',
plane_id='a1',
current_city_id='c1001')
self.utils.add_city_to_player(player_id='foo', city_id='c1001')
self.utils.add_city_to_player(player_id='foo', city_id='c1002')
self.utils.add_city_to_player(player_id='foo', city_id='c1003')
# Get the new cities added to the player
_, result = self.utils.get_player_attributes(
player_id='foo', attributes_to_get=['cities'])
player_cities = result.get('cities')
jobs, _ = self.utils.update_city_with_new_jobs(
player_id='foo', city_id='c1001', player_cities=player_cities)
jobs_ids_to_remove = [
jobs.popitem()[0],
jobs.popitem()[0],
jobs.popitem()[0]
]
self.utils.remove_jobs_from_city(player_id='foo',
city_id='c1001',
list_of_jobs=jobs_ids_to_remove)
_, result = self.utils.get_player_attributes(
player_id='foo', attributes_to_get=['cities'])
city_jobs = result.get('cities').get('c1001').get('jobs')
print(len(city_jobs))
def test_depart_plane_too_far(self):
"""
Test departing a plane with a distance beyond the planes range
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='foo', balance=100000)
self.utils.add_plane_to_player(player_id='foo',
plane_id='a1',
current_city_id='c1001')
self.utils.add_city_to_player(player_id='foo', city_id='c1001')
self.utils.add_city_to_player(player_id='foo', city_id='c1002')
self.utils.add_city_to_player(player_id='foo', city_id='c1003')
# Get the new cities and plane added to the player
_, result = self.utils.get_player_attributes(
player_id='foo', attributes_to_get=['cities', 'planes'])
plane_1_id, plane_1_values = result.get('planes').popitem()
success, result = self.utils.depart_plane(player_id='foo',
plane_id=plane_1_id,
plane=plane_1_values,
destination_city_id='c1002')
self.assertFalse(success)
self.assertEqual('Destination city is beyond the range of the plane',
result)
def test_plane_load_jobs_too_many_already_loaded(self):
"""
Test loading a plane with too many already loaded
"""
shared_test_utils.create_table()
self.http_client.post('/v1/player')
self.http_client.post('/v1/planes',
json={
'plane': 'a1',
'city': 'c1001'
})
self.http_client.post('/v1/cities', json={'city': 'c1001'})
self.http_client.post('/v1/cities', json={'city': 'c1002'})
self.http_client.post('/v1/cities', json={'city': 'c1003'})
jobs = self.http_client.get('/v1/cities/c1001/jobs').get_json().get(
'jobs')
plane_id, _ = self.http_client.get('/v1/planes').get_json().get(
'planes').popitem()
# Pick some jobs of compatible type
job_ids = [
key for key, values in jobs.items()
if values.get('job_type') == 'C'
][:8]
result = self.http_client.put(f'/v1/planes/{plane_id}/load',
json={'loaded_jobs': job_ids[:4]})
self.assertEqual(200, result.status_code)
result = self.http_client.put(f'/v1/planes/{plane_id}/load',
json={'loaded_jobs': job_ids[5:]})
self.assertEqual(400, result.status_code)
self.assertEqual('Not enough capacity',
result.get_data().decode('utf-8'))
def test_cities_post_city_not_exist(self):
"""
Test creating a city when city id does not exist
"""
shared_test_utils.create_table()
result = self.http_client.post('/v1/cities?city', json={'city': 'foobar123'})
self.assertEqual('City does not exist', result.get_data().decode('utf-8'))
self.assertEqual(400, result.status_code)
def test_cities_get_player_not_exist(self):
"""
Test getting cities when player does not exist
"""
shared_test_utils.create_table()
result = self.http_client.get('/v1/cities')
self.assertEqual('Player does not exist', result.get_data().decode('utf-8'))
self.assertEqual(404, result.status_code)
def test_cities_post_player_not_exist(self):
"""
Test creating a city when player does not exist
"""
shared_test_utils.create_table()
result = self.http_client.post('/v1/cities', json={'city': 'c1001'})
self.assertEqual('Purchase failed', result.get_data().decode('utf-8'))
self.assertEqual(400, result.status_code)
def test_get_player_attributes_not_exist(self):
"""
Test getting player attributes when player does not exist
"""
shared_test_utils.create_table()
success, result = self.utils.get_player_attributes(
player_id='foo', attributes_to_get=['player_id'])
self.assertFalse(success)
self.assertEqual('Player does not exist', result)
def test_create_player(self):
"""
Test creating a player
"""
shared_test_utils.create_table()
created, message = self.utils.create_player(player_id='foo',
balance=10000)
self.assertTrue(created)
self.assertEqual('Player "foo" created with balance: 10000', message)
def test_handle_plane_landed(self):
"""
Test unloading a plane once it has landed
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='foo', balance=100000)
self.utils.add_plane_to_player(player_id='foo',
plane_id='a1',
current_city_id='c1005')
self.utils.add_city_to_player(player_id='foo', city_id='c1005')
self.utils.add_city_to_player(player_id='foo', city_id='c1036')
self.utils.add_city_to_player(player_id='foo', city_id='c1003')
# Get the new cities and plane added to the player
_, result = self.utils.get_player_attributes(
player_id='foo', attributes_to_get=['cities', 'planes'])
plane_1_id, plane_1_values = result.get('planes').popitem()
player_cities = result.get('cities')
# Generate some random jobs
jobs = self.utils.generate_random_jobs(player_cities=player_cities,
current_city_id='c1005',
count=8)
# Add the jobs to the plane
success, _ = self.utils.add_jobs_to_plane(player_id='foo',
plane_id=plane_1_id,
list_of_jobs=jobs)
self.assertTrue(success)
self.utils.depart_plane(player_id='foo',
plane_id=plane_1_id,
plane=plane_1_values,
destination_city_id='c1036',
eta=1)
# Get the updated plane
_, result = self.utils.get_player_attributes(
player_id='foo', attributes_to_get=['planes'])
_, plane_1_values = result.get('planes').popitem()
# Check the result of handling the plane landing
success, result = self.utils.handle_plane_landed(player_id='foo',
plane_id=plane_1_id,
plane=plane_1_values)
self.assertTrue(success)
self.assertLess(24000, int(result.get('balance')))
# Check the updated plane for the correct values after landing the plane
_, result = self.utils.get_player_attributes(
player_id='foo', attributes_to_get=['planes'])
_, plane_1_values = result.get('planes').popitem()
self.assertEqual(0, plane_1_values['eta'])
self.assertEqual('none', plane_1_values['destination_city_id'])
self.assertEqual('c1036', plane_1_values['current_city_id'])
self.assertGreater(8, len(plane_1_values['loaded_jobs']))
def test_player_post(self):
"""
Test creating a player
"""
shared_test_utils.create_table()
result = self.http_client.post('/v1/player')
self.assertEqual('Player "test_player_1" created with balance: 100000',
result.get_data().decode('utf-8'))
self.assertEqual(201, result.status_code)
def test_plane_load_bad_player(self):
"""
Test loading a plane with a bad player id
"""
shared_test_utils.create_table()
result = self.http_client.put('/v1/planes/12345/load',
json={'jobs': 'foo'})
self.assertEqual('Player does not exist',
result.get_data().decode('utf-8'))
self.assertEqual(400, result.status_code)
def test_add_plane_to_player_not_exist(self):
"""
Test adding a plane to a player that does not exist
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='foo', balance=10000)
success, result = self.utils.add_plane_to_player(
player_id='foo', plane_id='foo123', current_city_id='c1001')
self.assertFalse(success)
self.assertEqual('Plane does not exist', result)
def test_add_plane_to_player(self):
"""
Test adding a plane to a player
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='foo', balance=200)
success, result = self.utils.add_plane_to_player(
player_id='foo', plane_id='a1', current_city_id='c1001')
self.assertTrue(success)
self.assertEqual(0, result.get('balance'))
def test_add_city_to_player_not_exist(self):
"""
Test adding a city to a player when city does not exist
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='foo', balance=10000)
success, result = self.utils.add_city_to_player(player_id='foo',
city_id='foo123')
self.assertFalse(success)
self.assertEqual('City does not exist', result)
def test_add_city_to_player(self):
"""
Test adding a city to a player
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='foo', balance=10000)
success, result = self.utils.add_city_to_player(player_id='foo',
city_id='c1001')
self.assertTrue(success)
self.assertEqual(7222, result.get('balance'))
def test_planes_post_plane_not_exist(self):
"""
Test adding a plane to a player when plane id is bad
"""
shared_test_utils.create_table()
result = self.http_client.post('/v1/planes',
json={'plane': 'foobar123'})
self.assertEqual('Plane does not exist',
result.get_data().decode('utf-8'))
self.assertEqual(400, result.status_code)
def test_add_plane_to_player_cant_afford(self):
"""
Test adding a plane to a player when player cannot afford
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='foo', balance=199)
success, result = self.utils.add_plane_to_player(
player_id='foo', plane_id='a1', current_city_id='c1001')
self.assertFalse(success)
self.assertEqual('Purchase failed', result)
def test_player_post_already_exist(self):
"""
Test creating a player that already exists
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='test_player_1', balance=100000)
result = self.http_client.post('/v1/player')
self.assertEqual('Player "test_player_1" already exists',
result.get_data().decode('utf-8'))
self.assertEqual(400, result.status_code)
def test_get_player_attributes(self):
"""
Test getting player attributes
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='foo', balance=10000)
success, result = self.utils.get_player_attributes(
player_id='foo', attributes_to_get=['player_id'])
self.assertTrue(success)
self.assertEqual('foo', result['player_id'])
def test_cities_post_city_cant_afford(self):
"""
Test creating a city when player cant afford it
"""
shared_test_utils.create_table()
self.utils.create_player(player_id=self.player_name, balance=1000)
# Make the request and assert the response
result = self.http_client.post('/v1/cities', json={'city': 'c1001'})
self.assertEqual('Purchase failed', result.get_data().decode('utf-8'))
self.assertEqual(400, result.status_code)
def test_get_player_city_jobs_not_enough(self):
"""
Test getting jobs for a city when player only has one city
"""
shared_test_utils.create_table()
self.utils.create_player(player_id=self.player_name, balance=100000)
self.utils.add_city_to_player(player_id=self.player_name, city_id='c1001')
result = self.http_client.get('/v1/cities/c1001/jobs')
self.assertEqual(400, result.status_code)
self.assertEqual('Player does not own enough cities', result.get_data().decode('utf-8'))
def test_cities_get(self):
"""
Test getting cities
"""
shared_test_utils.create_table()
self.utils.create_player(player_id=self.player_name, balance=100000)
self.utils.add_city_to_player(player_id=self.player_name, city_id='c1001')
result = self.http_client.get('/v1/cities')
self.assertEqual(cities['c1001'].city_id, result.get_json()['cities']['c1001']['city_id'])
self.assertEqual(200, result.status_code)
def test_player_get(self):
"""
Test getting a player
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='test_player_1', balance=100000)
result = self.http_client.get('/v1/player')
self.assertEqual({
'player_id': 'test_player_1',
'balance': 100000
}, result.get_json())
self.assertEqual(200, result.status_code)
def test_plane_load_invalid_plane(self):
"""
Test loading a plane with invalid plane
"""
shared_test_utils.create_table()
self.http_client.post('/v1/player')
self.http_client.post('/v1/planes',
json={
'plane': 'a1',
'city': 'c1001'
})
result = self.http_client.put('/v1/planes/12345/load',
json={'jobs': 'foo'})
self.assertEqual('Invalid plane_id', result.get_data().decode('utf-8'))
self.assertEqual(400, result.status_code)
def test_add_city_to_player_already_owned(self):
"""
Test adding a city to a player when player already owns city
"""
shared_test_utils.create_table()
self.utils.create_player(player_id='foo', balance=20000)
success, result = self.utils.add_city_to_player(player_id='foo',
city_id='c1001')
self.assertTrue(success)
self.assertEqual(17222, result.get('balance'))
success, result = self.utils.add_city_to_player(player_id='foo',
city_id='c1001')
self.assertFalse(success)
self.assertEqual('Purchase failed', result)
