class TestGet(unittest.TestCase): @classmethod def setUp(self): self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() app.testing = True app.config['MONGO_URI'] = self.server.uri self.client = app.test_client() @classmethod def tearDown(self): self.server.stop() # os.close(self.db_fd) # os.unlink(app.config['MONGO_URI']) @classmethod def test_getlist(self): document = DOCUMENT future = go(self.client.get, '/api/robot') request = self.server.receives() request.reply(document) http_response = future() data = http_response.get_data(as_text=True) self.assertIn('not_a_robot', data) self.assertIn('kawada-hironx', data)
class BaseTestCase(TestCase): def create_app(self): app.config.from_object('project.config.TestingConfig') self.server = MockupDB(auto_ismaster=True) self.server.run() app.config['MONGO_URI'] = self.server.uri mongo.init_app(app) return app def setUp(self): pass def tearDown(self): self.server.stop()
class BaseTestCase(unittest.TestCase): server = None @classmethod def setUpClass(self): self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() # create mongo connection to mock server app.app.testing = True app.app.config['MONGO_URI'] = self.server.uri self.app = app.app.test_client() @classmethod def tearDownClass(self): self.server.stop() def test_getDataSources(self): # arrange future = go(self.app.get, '/dataSources') request = self.server.receives( Command({ 'find': 'dataSources', 'filter': {} }, flags=4, namespace='app')) request.ok( cursor={ 'id': 0, 'firstBatch': [{ 'name': 'Google', 'url': 'http://google.com/rest/api' }, { 'name': 'Rest', 'url': 'http://rest.com/rest/api' }] }) # act http_response = future() # assert data = http_response.get_data(as_text=True) self.assertIn('http://google.com/rest/api', data) self.assertIn('http://rest.com/rest/api', data)
class Test(TestCase): def setUp(self): self.app = app.app.test_client() self.server = MockupDB(auto_ismaster=True) self.server.run() def tearDown(self): self.server.stop() def test_index(self): response = self.app.get('/') assert response.status_code == 200 def test_search_method_not_allowed(self): response = self.app.get('/supermercado/assembler') assert response.status_code == 405 def test_search_is_number(self): product_id = 181 response = self.app.post('/supermercado/assembler?search='+str(product_id)) response_json = json.loads(response.data) if app.mongo.db.products.find_one({"id": product_id}): assert response_json['count'] == 1 assert response_json['products'][0]['id'] == product_id else: assert response_json['count'] == 0 def test_search_is_palindrome(self): response = self.app.post('/supermercado/assembler?search=daad') response_json = json.loads(response.data) assert response_json['discount'] == True def test_search_is_not_palindrome(self): response = self.app.post('/supermercado/assembler?search=daads') response_json = json.loads(response.data) assert response_json['discount'] == False def test_search_is_palindrome_but_less_4_characters(self): response = self.app.post('/supermercado/assembler?search=dad') response_json = json.loads(response.data) assert response_json['discount'] == False
class FlaskrTestCase(unittest.TestCase): @classmethod def setUp(self): self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() app.config['TESTING'] = True app.config['MONGO_URI'] = self.server.uri self.app = app.test_client() @classmethod def tearDownClass(self): self.server.stop() def test_outputs(self): rv = self.app.get('/outputs') ','.join(SUPPORTED) in rv.data.decode("utf-8") def test_msg_with_output(self): rv = self.app.get('/?output=json') self.assertEquals({'imie': 'Natalia', 'mgs': 'Hello World!'}, rv.json)
class PyMongoTestSuite(object): @pytest.fixture(autouse=True) def mocked_mongo(self): try: self.server = MockupDB(auto_ismaster={"maxWireVersion": 3}) self.server.run() yield finally: self.server.stop() @pytest.fixture(autouse=True) def restored_pymongo_config(self): orig = dict(config.__dict__) yield config.__dict__ = orig @pytest.fixture(autouse=True) def uninstrument_pymongo(self): yield uninstrument()
class MockupDBFlaskTest(unittest.TestCase): def setUp(self): self.server = MockupDB(3000, 'mongodb://localhost') self.server.run() # print('11111111111',self.server.uri) self.app = make_app(self.server.uri).test_client() print('000000000', self.app.get) def tearDown(self): self.server.stop() def test(self): future = go(self.app.get, "/pages/my_page_name") print('11111111', future) request = self.server.receives() print('22222', request) request.reply({"contents": "foo"}) http_response = future() print('333333333', http_response.get_data(as_text=True)) self.assertEqual("foo", http_response.get_data(as_text=True))
def test_unix_domain_socket(self): tmp = tempfile.NamedTemporaryFile(delete=False, suffix='.sock') tmp.close() server = MockupDB(auto_ismaster={'maxWireVersion': 3}, uds_path=tmp.name) server.run() self.assertTrue( server.uri.endswith('.sock'), 'Expected URI "%s" to end with ".sock"' % (server.uri, )) self.assertEqual(server.host, tmp.name) self.assertEqual(server.port, 0) self.assertEqual(server.address, (tmp.name, 0)) self.assertEqual(server.address_string, tmp.name) client = MongoClient(server.uri) with going(client.test.command, {'foo': 1}) as future: server.receives().ok() response = future() self.assertEqual(1, response['ok']) server.stop() self.assertFalse(os.path.exists(tmp.name))
class TestProductController(unittest.TestCase): @classmethod def setUpClass(self) -> None: self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() Config.MONGO_URI = self.server.uri app = create_app() self.app = app.test_client() @classmethod def tearDownClass(self) -> None: self.server.stop() def test_create_product(self): to_insert = { "title": "First Aid kit", "description": "Your helper in journey", "params": { 'price': 350, 'class': 'B' } } headers = [('Content-Type', 'application/json')] go(self.app.post, '/api/product', data=dumps(to_insert), headers=headers) rv = self.server.receives() new_object_id = str(rv.docs[0]['documents'][0]['_id']) go(self.app.get, f'/api/product/{new_object_id}', headers=headers) request = self.server.receives() request_status = request.ok(cursor={'id': new_object_id, 'firstBatch': [ to_insert ]}) self.assertTrue(request_status)
class SignInTest(unittest.TestCase): def setUp(self): """ Prepare the test envirement. start the server to mockup the database """ self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() app.testing = True app.config['MONGO_URI'] = self.server.uri self.app = app.test_client() def tearDown(self): """shuts down the mockupDB server""" self.server.stop() def test_signin_invalid_client(self): USER_REQ = OpMsg({ "find": "users", "filter": {"login": "******", "password": "******"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice") CLIENT_REQ = OpMsg({ "find": "clients", "filter": {"client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice") future = go(self.app.post, '/auth/signin', json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) request = self.server.receives(USER_REQ) request.ok(cursor={'id': 0, 'firstBatch': [USER]}) request = self.server.receives(CLIENT_REQ) request.ok(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(future().status_code, 400) def test_signin_invalid_user(self): USER_REQ = OpMsg({ "find": "users", "filter": {"login": "******", "password": "******"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice") future = go(self.app.post, '/auth/signin', json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) request = self.server.receives(USER_REQ) request.ok(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(future().status_code, 400) def test_signin_valid_user(self): USER_REQ = OpMsg({ "find": "users", "filter": {"login": "******", "password": "******"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice") CLIENT_REQ = OpMsg({ "find": "clients", "filter": {"client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice") future = go(self.app.post,'/auth/signin', json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) request = self.server.receives(USER_REQ) request.ok(cursor={'id': 0, 'firstBatch': [USER]}) request = self.server.receives(CLIENT_REQ) request.ok(cursor={'id': 0, 'firstBatch': [CLIENT]}) self.assertEqual(future().status_code, 200) def test_signin_get_users(self): USER_REQ = OpMsg({ "find": "users", "filter": {}, "projection": {"password": 0}, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice") user = { "_id": "5b37fff8bbf300b7ef185042", "login": "******", "password": "******", "role": "admin" } access_token = generate_access_token( user=user, pivate_key=app.config['PRIVATE_KEY'], auth_host=app.config['AUTH_HOST'], token_ttl=app.config['TOKEN_TTL'], auth_algo=app.config['AUTH_ALGO'] ) headers = {'Authorization': 'Bearer {}'.format(access_token['access_token'])} future = go(self.app.get, '/auth/signin', headers=headers) request = self.server.receives(USER_REQ, timeout=60) request.ok(cursor={'id': 0, 'firstBatch': [USER]})
class AppTest(unittest.TestCase): ''' Unit test for app.py. Uses mockupdb to act as the database. Each endpoint is tested in a seperate method. ''' def setUp(self): ''' Set up test fixtures ''' self.user = '******' self.email = '*****@*****.**' self.building = 'test_building' self.image_path = os.path.join(os.environ.get('FULL_IMAGE_DIR'), 'MooreHall_1.jpg') self.server = MockupDB(auto_ismaster={"maxWireVersion": 6}) self.server.run() self.app = app.create_test_app(self.server.uri).test_client() def tearDown(self): ''' Take down test fixtures ''' self.server.stop() def test_addUser(self): '''Test 1: /addUser endpoint''' # No username or email provided res = go(self.app.get, '/addUser', query_string={'user_name': '', 'user_email': ''}) self.assertEqual(res().status_code, 400) # User doesn't exist res = go(self.app.get, '/addUser', query_string={'user_name': self.user, 'user_email': self.email}) self.server.reply(cursor={'id': 0, 'firstBatch': [None]}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'user': self.user, 'email': self.email}]}) self.assertEqual(res().status_code, 200) # User was added twice res = go(self.app.get, '/addUser', query_string={'user_name': self.user, 'user_email': self.email}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'user': self.user, 'email': self.email}]}) self.assertEqual(res().status_code, 400) # def test_addFriend(self): # ''' Test 2: /addFriend endpoint''' # # No username/friend provided # res = go(self.app.get, '/addFriend', query_string={'user_email': '', 'friend_email': ''}) # self.assertEqual(res().status_code, 400) # # Friend was added successfully # res = go(self.app.get, '/addFriend', query_string={'user_email': self.email, 'friend_email': '*****@*****.**'}) # self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list': []}]}) # self.server.reply({'n': 1, 'nModified': 1, 'ok': 1.0, 'updatedExisting': True}) # self.assertEqual(res().status_code, 200) # # Add friend to non-existent user # res = go(self.app.get, '/addFriend', query_string={'user_email': 'not_a_user', 'friend_email': 'friend_test'}) # self.server.reply(cursor={'id': 0, 'firstBatch': []}) # self.assertEqual(res().status_code, 400) def test_deleteFriend(self): ''' Test 3: /deleteFriend endpoint''' # Bad arguments res = go(self.app.get, '/deleteFriend', query_string={'user_email': '', 'friend_email': ''}) self.assertEqual(res().status_code, 400) # Friend was deleted successfully res = go(self.app.get, '/deleteFriend', query_string={'user_email': self.email, 'friend_email': '*****@*****.**'}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list': ['*****@*****.**']}]}) self.server.reply({'n': 1, 'ok': 1.0}) self.assertEqual(res().status_code, 200) # Friend does not exist res = go(self.app.get, '/deleteFriend', query_string=({'user_email': self.email, 'friend_email': 'i_dont_exist'})) self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list': ['i_do_exist']}]}) self.assertEqual(res().status_code, 400) def test_registerLocation(self): ''' Test 4: /registerLocation endpoint''' # Location update successful res = go(self.app.post, '/registerLocation', data=json.dumps({'user_email': self.email, 'location': {'latitude': '0.000','longitude': '0.000'}})) self.server.reply({'n': 1, 'nModified': 1, 'ok': 1.0, 'updatedExisting': True}) self.assertEqual(res().status_code, 200) # Missing user email res = go(self.app.post, '/registerLocation', data=json.dumps({'user_email': '', 'location': {'latitude': '0.000','longitude': '0.000'}})) self.assertEqual(res().status_code, 400) # Missing location res = go(self.app.post, '/registerLocation', data=json.dumps({'user_email': self.email})) self.assertEqual(res().status_code, 400) def test_lookup(self): ''' Test 5: /lookup endpoint''' # No friend/user name provided res = go(self.app.get,'/lookup', query_string={'user_email': '', 'friend_email': ''}) self.assertEqual(res().status_code , 400) # No such user res = go(self.app.get,'/lookup', query_string={'user_email': self.user, 'friend_email': 'n/a'}) self.server.reply(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(res().status_code , 400) # Requested user not in friend list res = go(self.app.get,'/lookup', query_string={'user_email': self.email, 'friend_email': 'not_a_friend'}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list': ['a_friend']}]}) self.assertEqual(res().status_code , 400) # Look up friend who is not sharing location res = go(self.app.get,'/lookup', query_string={'user_email': self.email, 'friend_email': 'dont_look_at_me_rn'}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list': ['dont_look_at_me_rn']}]}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': 'dont_look_at_me_rn', 'location_sharing': False}]}) self.assertEqual(res().status_code , 401) # Look up friend's location successfully res = go(self.app.get, '/lookup', query_string={'user_email': self.email, 'friend_email': 'look_at_me'}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list': ['look_at_me']}]}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': 'look_at_me', 'location_sharing': True, 'location': {'x': 4, 'y': 4}, 'indoor_location': {'building': 'MooreHall', 'floor': '1', 'x': 16, 'y': 82, 'room': 1009}, 'last_seen_indoor': 0.0}]}) outdoor = {'x': 4, 'y': 4} indoor = {'building': 'MooreHall', 'floor': '1', 'x': 16, 'y': 82, 'room': 1009} response = res() self.assertEqual(response.status_code, 200) self.assertEqual(response.get_json()['location']['outdoor_location'], outdoor) self.assertEqual(response.get_json()['location']['indoor_location'], indoor) self.assertTrue(response.get_json()['minutes_ago_indoor']) def test_toggle(self): '''Test 6: /toggle endpoint''' # No username provided res = go(self.app.get, '/toggle', query_string={'user_email': ''}) self.assertEqual(res().status_code, 400) # User doesn't exist res = go(self.app.get, '/toggle', query_string={'user_email': 'i_dont_exist'}) self.server.reply(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(res().status_code, 400) # Untoggle res = go(self.app.get, '/toggle', query_string={'user_email': self.email}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': 'toggle_me', 'location_sharing': False}]}) self.server.reply({'n': 1, 'ok': 1.0}) self.assertEqual(res().status_code, 200) def test_getFriends(self): '''Test 7: /getFriends endpoint''' # No username provided res = go(self.app.get, '/getFriends', query_string={'user_email': ''}) self.assertEqual(res().status_code, 400) # User doesn't exist res = go(self.app.get, '/getFriends', query_string={'user_email': 'i_dont_exist'}) self.server.reply(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(res().status_code, 400) # User exists and has friends res = go(self.app.get, '/getFriends', query_string={'user_email': self.email}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list':['friend_1']}]}) self.assertEqual(res().status_code, 200) def test_getBuildingMetadata(self): '''Test 8: /getBuildingMetadata endpoint''' # No building name provided res = go(self.app.get, '/getBuildingMetadata', query_string={'building_name': ''}) self.assertEqual(res().status_code, 400) # Building not in database res = go(self.app.get, '/getBuildingMetadata', query_string={'building_name': self.building}) self.server.reply(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(res().status_code, 401) # Get number of floor plans in db for building res = go(self.app.get, '/getBuildingMetadata', query_string={'building_name': self.building}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'building_name': self.building, 'location': {'longitude': 0.0, 'latitude': 0.0}}]}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'building_name': self.building, 'location': {'longitude': 0.0, 'latitude': 0.0}, 'floor': '1', 'vertices': [(0,0), (100,0), (0,100), (100,100)]}] } ) self.assertEqual(res().status_code, 200) self.assertEqual(res().get_json()['number_of_floors'], 1) self.assertEqual(res().get_json()['location'], {'longitude': 0.0, 'latitude': 0.0}) def test_modal_to_pixel(self): '''Test 9: modal_to_pixel function''' ''' Using default shape=[100, 100] Condition evaluation: TTFF Branch coverage: 50% ''' res = go(my_app.model_to_pixel, -1, -1) self.assertEqual(res(), (0, 0)) ''' Using shape=[500, 500] Condition evaluation: FFTT Branch coverage: 100% ''' res = go(my_app.model_to_pixel, 101, 101, [500, 500]) self.assertEqual(res(), (500, 500)) def test_add_floor(self): pass def test_get_floor_image(self): pass def test_getName(self): '''Test 10: /getName endpoint''' # No email provided res = go(self.app.get, '/getName', query_string={'email': ''}) self.assertEqual(res().status_code, 400) # No user res = go(self.app.get, '/getName', query_string={'email': '*****@*****.**'}) self.server.reply(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(res().status_code, 400) # User exists res = go(self.app.get, '/getName', query_string={'email': self.email}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'user': self.user, 'email': self.email}]}) self.assertEqual(res().status_code, 200) def test_add_building(self): '''Test 11: /addBuilding endpoint''' # Building already exist name = 'my_new_building' longitude = 1.0 latitude = 10.0 res = go(self.app.get, '/addBuilding', query_string={'building_name': name, 'longitude': longitude, 'latitude': latitude}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'building_name': name, 'location': {'longitude': longitude, 'latitude': latitude}}]}) self.assertEqual(res().status_code, 401) # Added successfully name = 'my_new_building' longitude = 1.0 latitude = 10.0 res = go(self.app.get, '/addBuilding', query_string={'building_name': name, 'longitude': longitude, 'latitude': latitude}) self.server.reply(cursor={'id': 0, 'firstBatch': [None]}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'building_name': name, 'location': {'longitude': longitude, 'latitude': latitude}}]}) self.assertEqual(res().status_code, 200) # Missing arguments res = go(self.app.get, '/addBuilding', query_string={'building_name': 'a_building'}) self.assertEqual(res().status_code, 400) def test_registerIndoor(self): '''Test 12: /registerIndoor endpoint''' location={'building': 'MooreHall','floor': '1', 'x': 15, 'y': 58} # Success res = go(self.app.post, '/registerIndoor', data=json.dumps({'user_email': self.email, 'location': location})) self.server.reply({'n': 1, 'ok': 1.0}) self.server.reply({'n': 1, 'ok': 1.0}) self.assertEqual(res().status_code, 200) # Missing user email res = go(self.app.post, '/registerIndoor', data=json.dumps({'user_email': '', 'location': location})) self.assertEqual(res().status_code, 400) # Missing location res = go(self.app.post, '/registerIndoor', data=json.dumps({'user_email': self.email, 'location': {}})) self.assertEqual(res().status_code, 400) # No floor plan found res = go(self.app.post, '/registerIndoor', data=json.dumps({'user_email': self.email, 'location': {'building': 'Boelter', 'floor': '1', 'x': 16, 'y': 82}})) self.assertEqual(res().status_code, 400) ''' Return: no floor plan found # Register location successfully res = go(self.app.post, '/registerIndoor', data=json.dumps({'user_email': self.email, 'location': {'building': 'MooreHall', 'floor': '1', 'x': 16, 'y': 82}})) print(res().data) #self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'location_sharing': True, 'indoor_location': {'building': 'MooreHall', 'floor': '1', 'x': 16, 'y': 82, 'room': 1009}}]}) #self.server.reply({'n': 1, 'nModified': 1, 'ok': 1.0, 'updatedExisting': True}) self.assertEqual(res().status_code, 200) ''' def test_getFloorImage(self): '''Test 13: /getFloorImage endpoint''' res = go(self.app.get, '/getFloorImage', query_string={'building_name': self.building, 'floor': 1}) self.assertEqual(res().status_code, 200) def test_addFloor(self): '''Test 14: /addFloor endpoint''' res = go(self.app.post, '/addFloor', data={'building_name': self.building, 'floor_number': 1, 'floor_plan': (io.BytesIO(open(self.image_path, 'rb').read()), 'MooreHall_1.jpg')}) self.server.reply(cursor={'id': 0, 'firstBatch': [{'building_name': self.building, 'location': dict(longitude=10, latitude=10)}]}) self.server.reply(cursor={'id': 0, 'firstBatch': [None]}) self.assertEqual(res().status_code, 200) # No building_name res = go(self.app.post, '/addFloor', data={'building_name': '', 'floor_number': 1, 'floor_plan': (io.BytesIO(open(self.image_path, 'rb').read()), 'MooreHall_1.jpg')}) self.assertEqual(res().status_code, 400) # No floor res = go(self.app.post, '/addFloor', data={'building_name': self.building, 'floor_plan': (io.BytesIO(open(self.image_path, 'rb').read()), 'MooreHall_1.jpg')}) self.assertEqual(res().status_code, 400) # No image res = go(self.app.post, '/addFloor', data={'building_name': self.building, 'floor_number': 1}) self.assertEqual(res().status_code, 400)
class TestLikedDislikedShop(unittest.TestCase): def setUp(self): """ Prepare the test envirement. start the server to mockup the database """ self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() app.testing = True app.config['MONGO_URI'] = self.server.uri self.app = app.test_client() self.token = mock_access_token()['access_token'] self.auth_header = {'Authorization': 'Bearer {}'.format(self.token)} def tearDown(self): self.server.stop() def test_get_liked_disliked_shops(self): future = go(self.app.get, '/shops/liked', headers=self.auth_header, json=SHOP_REQ) request = self.server.receives() request.ok(cursor={'id': 0, 'firstBatch': [SHOP_RESULT]}) self.assertEqual(future().status_code, 200) future = go(self.app.get, '/shops/disliked', headers=self.auth_header, json=SHOP_REQ) request = self.server.receives() request.ok(cursor={'id': 0, 'firstBatch': [DISLIKER]}) request = self.server.receives() request.ok(cursor={'id': 0, 'firstBatch': [SHOP_RESULT]}) self.assertEqual(future().status_code, 200) def test_post_like_dislike_shops(self): future = go(self.app.post, '/shops/liked', headers=self.auth_header, json=SHOP_REQ) request = self.server.receives() request.ok(cursor={'id': 0, 'firstBatch': []}) request = self.server.receives() request.ok(cursor={'id': 0, 'firstBatch': []}) request = self.server.receives() request.ok({ 'n': 1, 'nModified': 1, 'ok': 1.0, 'updatedExisting': True }) self.assertEqual(future().status_code, 201) def test_delete_like_dislike_shop_valid(self): future = go(self.app.delete, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=self.auth_header) request = self.server.receives() request.ok(cursor={'id': 0, 'firstBatch': [SHOP_RESULT]}) request = self.server.receives() request.ok() request = self.server.receives() request.ok(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(future().status_code, 204)
class ManagerTestCase(unittest.TestCase): maxDiff = None # unittest: show full diff on assertion failure def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(self.loop) self.server = MockupDB(auto_ismaster={"maxWireVersion": 6}) self.server.run() self.server.autoresponds( Command("find", "switch_collection", namespace="topology_database"), { "cursor": { "id": 0, "firstBatch": [{ **d, "_id": i } for i, d in enumerate(TOPOLOGY_DATABASE_DATA)], } }, ) self._stack = AsyncExitStack() td = self._stack.enter_context(tempfile.TemporaryDirectory()) self.rpc_unix_sock = os.path.join(td, "l.sock") self._stack.enter_context( patch.object(settings, "REMOTE_DATABASE_MONGO_URI", self.server.uri)) self._stack.enter_context( patch.object(settings, "NEGOTIATOR_RPC_UNIX_SOCK_PATH", self.rpc_unix_sock)) self._stack.enter_context( patch("agile_mesh_network.ryu.amn_manager.OVSManager", DummyOVSManager)) self._stack.enter_context( # To avoid automatic connection to a relay. patch.object(settings, "IS_RELAY", True)) self._stack.enter_context( patch.object(events_scheduler, "RyuAppEventLoopScheduler")) self.ryu_ev_loop_scheduler = events_scheduler.RyuAppEventLoopScheduler( ) self._stack.enter_context(self.ryu_ev_loop_scheduler) async def command_cb(session, msg): assert isinstance(msg, RPCCommand) await self._rpc_command_cb(msg) self.rpc_server = self.loop.run_until_complete( self._stack.enter_async_context( RPCUnixServer(self.rpc_unix_sock, command_cb))) async def _rpc_command_cb(self, msg: RPCCommand): self.assertEqual(msg.name, "dump_tunnels_state") await msg.respond({"tunnels": []}) def tearDown(self): self.loop.run_until_complete(self._stack.aclose()) self.loop.run_until_complete(self.loop.shutdown_asyncgens()) self.loop.close() self.server.stop() def test_topology_database_sync(self): async def f(): async with AgileMeshNetworkManager( ryu_ev_loop_scheduler=self.ryu_ev_loop_scheduler ) as manager: manager.start_initialization() topology_database = manager.topology_database local_database = topology_database.local await local_database.is_filled_event.wait() self.assertTrue(local_database.is_filled) self.assertListEqual( topology_database.find_random_relay_switches(), [SwitchEntity.from_dict(SWITCH_ENTITY_RELAY_DATA)], ) with self.assertRaises(KeyError): topology_database.find_switch_by_mac(UNK_MAC) self.assertEqual( topology_database.find_switch_by_mac( SWITCH_ENTITY_BOARD_DATA["mac"]), SwitchEntity.from_dict(SWITCH_ENTITY_BOARD_DATA), ) self.assertListEqual( topology_database.find_switches_by_mac_list([]), []) self.assertListEqual( topology_database.find_switches_by_mac_list([UNK_MAC]), []) self.assertListEqual( topology_database.find_switches_by_mac_list( [UNK_MAC, SWITCH_ENTITY_BOARD_DATA["mac"]]), [SwitchEntity.from_dict(SWITCH_ENTITY_BOARD_DATA)], ) # TODO after resync extra tunnels/flows are destroyed self.loop.run_until_complete(asyncio.wait_for(f(), timeout=3)) def test_rpc(self): async def f(): rpc_responses = iter([ ("dump_tunnels_state", { "tunnels": [TUNNEL_MODEL_BOARD_DATA] }), ( "create_tunnel", { "tunnel": TUNNEL_MODEL_RELAY_DATA, "tunnels": [ TUNNEL_MODEL_BOARD_DATA, TUNNEL_MODEL_RELAY_DATA, ], }, ), ( "create_tunnel", { "tunnel": TUNNEL_MODEL_BOARD_DATA, "tunnels": [TUNNEL_MODEL_BOARD_DATA], }, ), ]) async def _rpc_command_cb(msg: RPCCommand): name, resp = next(rpc_responses) self.assertEqual(msg.name, name) await msg.respond(resp) with ExitStack() as stack: stack.enter_context( patch.object(self, "_rpc_command_cb", _rpc_command_cb)) stack.enter_context(patch.object(settings, "IS_RELAY", False)) async with AgileMeshNetworkManager( ryu_ev_loop_scheduler=self.ryu_ev_loop_scheduler ) as manager: manager.start_initialization() await manager._initialization_task self.assertDictEqual({}, manager._tunnel_creation_tasks) # Don't attempt to connect to unknown macs. manager.ask_for_tunnel(UNK_MAC) self.assertDictEqual({}, manager._tunnel_creation_tasks) # Connect to a switch, ensure that the task is cleaned up. manager.ask_for_tunnel(SECOND_MAC) await next(iter(manager._tunnel_creation_tasks.values())) self.assertDictEqual({}, manager._tunnel_creation_tasks) # Send a broadcast await next(iter(self.rpc_server.sessions)).issue_broadcast( "tunnel_created", { "tunnel": TUNNEL_MODEL_RELAY_DATA, "tunnels": [TUNNEL_MODEL_RELAY_DATA], }, ) await asyncio.sleep(0.001) # TODO unknown tunnels after resync are dropped via RPC expected_event_calls = [ # Initialization list: [TunnelModel.from_dict(TUNNEL_MODEL_BOARD_DATA)], # Initialization relay tunnel: [ TunnelModel.from_dict(TUNNEL_MODEL_BOARD_DATA), TunnelModel.from_dict(TUNNEL_MODEL_RELAY_DATA), ], # ask_for_tunnel: [TunnelModel.from_dict(TUNNEL_MODEL_BOARD_DATA)], # Broadcast: [TunnelModel.from_dict(TUNNEL_MODEL_RELAY_DATA)], ] for (args, kwargs), ev_expected in zip_equal( self.ryu_ev_loop_scheduler.send_event_to_observers. call_args_list, expected_event_calls, ): ev = args[0] self.assertListEqual( sorted(t for t, _ in ev.mac_to_tunswitch.values()), sorted(ev_expected), ) self.loop.run_until_complete(asyncio.wait_for(f(), timeout=3)) def test_flows(self): async def f(): async with AgileMeshNetworkManager( ryu_ev_loop_scheduler=self.ryu_ev_loop_scheduler ) as manager: manager.start_initialization() # TODO missing flows from RPC sync are added # TODO after packet in a tunnel creation request is sent # TODO after tunnel creation a flow is set up pass self.loop.run_until_complete(asyncio.wait_for(f(), timeout=3))
class TestShop(unittest.TestCase): def setUp(self): """ Prepare the test envirement. start the server to mockup the database """ self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() app.testing = True app.config['MONGO_URI'] = self.server.uri self.app = app.test_client() self.token = mock_access_token()['access_token'] self.auth_header = {'Authorization': 'Bearer {}'.format(self.token)} def tearDown(self): self.server.stop() def test_notoken(self): future = go(self.app.get, '/shops/5b3a7297d2e5ce5bbd3d0121') self.assertEqual(future().status_code, 401) future = go(self.app.put, '/shops/5b3a7297d2e5ce5bbd3d0121') self.assertEqual(future().status_code, 401) future = go(self.app.delete, '/shops/5b3a7297d2e5ce5bbd3d0121') self.assertEqual(future().status_code, 401) future = go(self.app.get, '/shops') self.assertEqual(future().status_code, 401) future = go(self.app.post, '/shops') self.assertEqual(future().status_code, 401) def test_invalid_token(self): headers = {'Authorization': 'Bearer invalid_token'} future = go(self.app.get, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=headers) self.assertEqual(future().status_code, 400) future = go(self.app.put, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=headers) self.assertEqual(future().status_code, 400) future = go(self.app.delete, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=headers) self.assertEqual(future().status_code, 400) future = go(self.app.get, '/shops', headers=headers) self.assertEqual(future().status_code, 400) future = go(self.app.post, '/shops', headers=headers) self.assertEqual(future().status_code, 400) def test_shop_notfound(self): future = go(self.app.get, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=self.auth_header) request = self.server.receives() request.ok(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(future().status_code, 400) future = go(self.app.put, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=self.auth_header, json=SHOP_REQ) request = self.server.receives() request.ok(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(future().status_code, 400) future = go(self.app.delete, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=self.auth_header) request = self.server.receives() request.ok(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(future().status_code, 400) def test_invalid_shop_id(self): future = go(self.app.get, '/shops/invalidid', headers=self.auth_header) self.assertEqual(future().status_code, 400) future = go(self.app.put, '/shops/invalidid', headers=self.auth_header) self.assertEqual(future().status_code, 400) future = go(self.app.delete, '/shops/invalidid', headers=self.auth_header) self.assertEqual(future().status_code, 400)
def mockdbserver(loop): server = MockupDB() server.run() yield server server.stop()
class functionsTest(unittest.TestCase): def setUp(self): self.server = MockupDB(auto_ismaster={"maxWireVersion": 3}) self.server.run() #self.testConf['mongo_url'] = self.testConf = { "mongo_url" : self.server.uri, "host_url": "https://lmp.nupursjsu.net", "host" : "127.0.0.1", "port" : 8080 } def tearDown(self): self.server.stop() def test_display_userdetails(self): user_details = {'userId': 'user1', 'firstName': 'myFirstName', 'lastName': 'myLastName', 'age': 20} userId = "user1" details = go(display_userdetails, userId, self.testConf) query = OpQuery({"userId": "user1"}, namespace="Books.myapp_user", fields={"_id": False}) request = self.server.receives(query) request.reply(user_details) output = details() for key in output: if key in user_details: self.assertEqual(user_details[key], output[key]) def test_display_bookdetails(self): book_details = {'userId': 'user1', 'firstName': 'myFirstName', 'lastName': 'myLastName', 'age': 20} userId = "user1" details = go(display_userdetails, userId, self.testConf) query = OpQuery({"userId": "user1"}, namespace="Books.myapp_user", fields={"_id": False}) request = self.server.receives(query) request.reply(book_details) output = details() for key in output: if key in book_details: self.assertEqual(book_details[key], output[key]) def test_update_bookdetails(self): book_details = {'userId': 'user1', 'firstName': 'myFirstName', 'lastName': 'myLastName', 'age': 20} userId = "user1" details = go(display_userdetails, userId, self.testConf) query = OpQuery({"userId": "user1"}, namespace="Books.myapp_user", fields={"_id": False}) request = self.server.receives(query) request.reply(book_details) output = details() for key in output: if key in book_details: self.assertEqual(book_details[key], output[key]) def test_update_userdetails(self): user_details = {'userId': 'user1', 'firstName': 'myFirstName', 'lastName': 'myLastName', 'age': 20} userId = "user1" details = go(display_userdetails, userId, self.testConf) query = OpQuery({"userId": "user1"}, namespace="Books.myapp_user", fields={"_id": False}) request = self.server.receives(query) request.reply(user_details) output = details() for key in output: if key in user_details: self.assertEqual(user_details[key], output[key])
class GetDataSourceTestCase(unittest.TestCase): @classmethod def setUpClass(self): self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() # create mongo connection to mock server app.testing = True app.config['MONGO_URI'] = self.server.uri self.app = app.test_client() @classmethod def tearDownClass(self): self.server.stop() def test_getDataSource(self): # arrange id = '5a8f1e368f7936badfbb0cfa' future = go(self.app.get, f'/dataSource/{id}') request = self.server.receives( Command( { 'find': 'dataSources', 'filter': { '_id': mockup_oid(id) }, 'limit': 1, 'singleBatch': True }, flags=4, namespace='app')) request.ok( cursor={ 'id': 0, 'firstBatch': [{ 'name': 'bla', 'url': 'http://google.com/rest/api' }] }) # act http_response = future() # assert self.assertIn('http://google.com/rest/api', http_response.get_data(as_text=True)) def test_getDataSource_404(self): id = '5a8f1e368f7936badfbb0cfb' future = go(self.app.get, f'/dataSource/{id}') request = self.server.receives( Command( { 'find': 'dataSources', 'filter': { '_id': mockup_oid(id) }, 'limit': 1, 'singleBatch': True }, flags=4, namespace='app')) request.ok(cursor={'id': 0, 'firstBatch': []}) # act http_response = future() # assert self.assertEqual(http_response.status_code, 404) def test_getDataSources(self): # arrange future = go(self.app.get, '/dataSources') request = self.server.receives( Command({ 'find': 'dataSources', 'filter': {} }, flags=4, namespace='app')) request.ok( cursor={ 'id': 0, 'firstBatch': [{ 'name': 'Google', 'url': 'http://google.com/rest/api' }, { 'name': 'Rest', 'url': 'http://rest.com/rest/api' }] }) # act http_response = future() # assert data = http_response.get_data(as_text=True) self.assertIn('http://google.com/rest/api', data) self.assertIn('http://rest.com/rest/api', data) def test_addDataSource(self): # arrange id = '5a924d7a29a6e5484dcf68be' headers = [('Content-Type', 'application/json')] # need to pass _id because pymongo creates one so it's impossible to match insert request without _ids toInsert = {'name': 'new', 'url': 'http://google.com', '_id': id} future = go(self.app.put, '/dataSource', data=dumps(toInsert), headers=headers) request = self.server.receives( Command( { 'insert': 'dataSources', 'ordered': True, 'documents': [{ 'name': 'new', 'url': 'http://google.com', '_id': mockup_oid(id) }] }, namespace='app')) request.ok(cursor={'inserted_id': id}) # act http_response = future() # assert data = http_response.get_data(as_text=True) self.assertIn(id, data) self.assertEqual(http_response.status_code, 201) def test_deleteDataSource(self): # arrange id = '5a8f1e368f7936badfbb0cfa' future = go(self.app.delete, f'/dataSource/{id}') request = self.server.receives( Command( { 'delete': 'dataSources', 'ordered': True, 'deletes': [{ 'q': { '_id': mockup_oid(id) }, 'limit': 1 }] }, namespace='app')) request.ok({'acknowledged': True, 'n': 1}) # act http_response = future() # assert self.assertIn(f'deleted {id}', http_response.get_data(as_text=True)) self.assertEqual(http_response.status_code, 202) def test_deleteDataSource_notFound(self): # arrange id = '5a8f1e368f7936badfbb0000' future = go(self.app.delete, f'/dataSource/{id}') request = self.server.receives( Command( { 'delete': 'dataSources', 'ordered': True, 'deletes': [{ 'q': { '_id': mockup_oid(id) }, 'limit': 1 }] }, namespace='app')) request.ok({'acknowledged': True, 'n': 0}) # act http_response = future() # assert self.assertIn(f'{id} not found', http_response.get_data(as_text=True)) self.assertEqual(http_response.status_code, 404)
class MockupDBFlaskTest(unittest.TestCase): def setUp(self): self.server = MockupDB(auto_ismaster=True) self.server.run() self.app = create_app(self.server.uri).test_client() def tearDown(self): self.server.stop() def mock_db_get(self, url=None): # dateStr = "2018-11-11T00:00:00.000Z" # date = dateutil.parser.parse(dateStr) request = self.server.receives( OpMsg('find', 'urls', filter={'shorturl': url})) request.ok(cursor={'id': 0, 'firstBatch': [mapping_dict[url]]}) def mock_db_update(self): request = self.server.pop().reply({"modified_count": 1}) def mock_db_get_many(self, url=None): request = self.server.pop() # request = self.server.receives( # OpMsg({"count": "urls", "query": {"shorturl": url}})) request.ok(cursor={ 'id': 0, 'firstBatch': [mapping_dict[url]], 'count': 1 }) def test_get_url_not_empty(self): future = go(self.app.get, "/urls/e5a53874fbde55") self.mock_db_get(url="e5a53874fbde55") self.mock_db_update() http_response = future() # print http_response.status # print http_response.mimetype # print http_response.response # print http_response.get_data() self.assertEqual(("Long url is : newlonnnn44\n"), http_response.get_data()) def test_get_url_not_found(self): future = go(self.app.get, "/urls/fggg874fbde55") self.mock_db_get(url="fggg874fbde55") http_response = future() self.assertEqual( "No long url found for this short url fggg874fbde55\n", http_response.get_data()) def test_get_access_time_all(self): future = go(self.app.get, "/urls/alltime_access/e5a53874fbde55") self.mock_db_get_many(url="e5a53874fbde55") http_response = future() self.assertEqual( "Access times for url: 'e5a53874fbde55'; for time duration: ' all' is: 1\n", http_response.get_data())
class SignInTest(unittest.TestCase): def setUp(self): self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() app.testing = True app.config['MONGO_URI'] = self.server.uri self.app = app.test_client() def tearDown(self): self.server.stop() def test_delete_user(self): USER_REQ = OpMsg({ "find": "users", "filter": {"login": "******"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice") user = { "_id": "5b37fff8bbf300b7ef185042", "login": "******", "password": "******", "role": "admin" } access_token = generate_access_token( user=user, pivate_key=app.config['PRIVATE_KEY'], auth_host=app.config['AUTH_HOST'], token_ttl=app.config['TOKEN_TTL'], auth_algo=app.config['AUTH_ALGO'] ) headers = {'Authorization': 'Bearer {}'.format(access_token['access_token'])} future = go(self.app.delete, '/auth/signup', headers=headers, json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) request = self.server.receives(USER_REQ) request.ok(cursor={'id': 0, 'firstBatch': [USER]}) self.server.receives().ok() request = self.server.receives(USER_REQ) request.ok(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(future().status_code, 204) def test_nonadmin_delete(self): user = { "_id": "5b37fff8bbf300b7ef185042", "login": "******", "password": "******", "role": "regular" } access_token = generate_access_token( user=user, pivate_key=app.config['PRIVATE_KEY'], auth_host=app.config['AUTH_HOST'], token_ttl=app.config['TOKEN_TTL'], auth_algo=app.config['AUTH_ALGO'] ) headers = {'Authorization': 'Bearer {}'.format(access_token['access_token'])} future = go(self.app.delete, '/auth/signup', headers=headers, json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) self.assertEqual(future().status_code, 401) def test_delete_nonexisting_user(self): USER_REQ = OpMsg({ "find": "users", "filter": {"login": "******"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice") user = { "_id": "5b37fff8bbf300b7ef185042", "login": "******", "password": "******", "role": "admin" } access_token = generate_access_token( user=user, pivate_key=app.config['PRIVATE_KEY'], auth_host=app.config['AUTH_HOST'], token_ttl=app.config['TOKEN_TTL'], auth_algo=app.config['AUTH_ALGO'] ) headers = {'Authorization': 'Bearer {}'.format(access_token['access_token'])} future = go(self.app.delete, '/auth/signup', headers=headers, json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) request = self.server.receives(USER_REQ) request.ok(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(future().status_code, 400) def test_signup_valid_client_success(self): USER_REQ = OpMsg({ "find": "users", "filter": {"login": "******"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice") CLIENT_REQ = OpMsg({ "find": "clients", "filter": {"client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice" ) future = go(self.app.post, '/auth/signup', json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) request = self.server.receives(CLIENT_REQ) request.ok(cursor={'id': 0, 'firstBatch': [CLIENT]}) request = self.server.receives(USER_REQ) request.ok(cursor={'id': 0, 'firstBatch': []}) self.server.receives().ok({"_id":USER["_id"]}) self.assertEqual(future().status_code, 201) def test_signup_create_existing_user(self): USER_REQ = OpMsg({ "find": "users", "filter": {"login": "******"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice") CLIENT_REQ = OpMsg({ "find": "clients", "filter": {"client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice" ) future = go(self.app.post, '/auth/signup', json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) request = self.server.receives(CLIENT_REQ) request.ok(cursor={'id': 0, 'firstBatch': [CLIENT]}) request = self.server.receives(USER_REQ) request.ok(cursor={'id': 0, 'firstBatch': [USER]}) def test_signup_with_invalid_client(self): CLIENT_REQ = OpMsg({ "find": "clients", "filter": {"client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice" ) future = go(self.app.post, '/auth/signup', json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) request = self.server.receives(CLIENT_REQ) request.ok(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(future().status_code, 400) def test_signup_with_invalid_email(self): USER_REQ = OpMsg({ "find": "users", "filter": {"login": "******"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice") CLIENT_REQ = OpMsg({ "find": "clients", "filter": {"client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice" ) future = go(self.app.post, '/auth/signup', json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) self.assertEqual(future().status_code, 400) def test_update_invalid_email(self): user = { "_id": "5b37fff8bbf300b7ef185042", "login": "******", "password": "******", "role": "admin" } access_token = generate_access_token( user=user, pivate_key=app.config['PRIVATE_KEY'], auth_host=app.config['AUTH_HOST'], token_ttl=app.config['TOKEN_TTL'], auth_algo=app.config['AUTH_ALGO'] ) headers = {'Authorization': 'Bearer {}'.format(access_token['access_token'])} future = go(self.app.put, '/auth/signup', headers=headers, json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) self.assertEqual(future().status_code, 400) def test_update_invalid_user(self): user = { "_id": "5b37fff8bbf300b7ef185042", "login": "******", "password": "******", "role": "admin" } access_token = generate_access_token( user=user, pivate_key=app.config['PRIVATE_KEY'], auth_host=app.config['AUTH_HOST'], token_ttl=app.config['TOKEN_TTL'], auth_algo=app.config['AUTH_ALGO'] ) headers = {'Authorization': 'Bearer {}'.format(access_token['access_token'])} future = go(self.app.put, '/auth/signup', headers=headers, json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) self.server.receives().ok(cursor={'id': 0, 'firstBatch': []}) self.assertEqual(future().status_code, 400) def test_update_valid(self): USER_REQ = OpMsg({ "find": "users", "filter": {"login": "******"}, "limit": 1, "singleBatch": True, "$db": "authservice", "$readPreference": {"mode": "primaryPreferred"}}, namespace="authservice") user = { "_id": "5b37fff8bbf300b7ef185042", "login": "******", "password": "******", "role": "admin" } access_token = generate_access_token( user=user, pivate_key=app.config['PRIVATE_KEY'], auth_host=app.config['AUTH_HOST'], token_ttl=app.config['TOKEN_TTL'], auth_algo=app.config['AUTH_ALGO'] ) headers = {'Authorization': 'Bearer {}'.format(access_token['access_token'])} future = go(self.app.put, '/auth/signup', headers=headers, json={ "userID": '', "login": "******", "password": "******", "client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d" }) request = self.server.receives(USER_REQ) request.ok(cursor={'id': 0, 'firstBatch': [USER]}) self.server.receives().ok() self.assertEqual(future().status_code, 400)