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)