def test_create_tempĺate(self, db_mock): db_mock.session = AlchemyMagicMock() token = generate_token() data = """{ "label": "SensorModel", "attrs": [ { "label": "temperature", "type": "dynamic", "value_type": "float" }, { "label": "model-id", "type": "static", "value_type": "string", "static_value": "model-001" } ] }""" params_query = {'content_type': 'application/json', 'data': data} result = TemplateHandler.create_template(params_query, token) self.assertIsNotNone(result) self.assertEqual(result['result'], 'ok') self.assertIsNotNone(result['template'])
def test_get_patient_by_id(app, attributes): """Should return patient by provided ID""" # BUG: SQLAlchemy first.return_value doesnt work! # When fixed, workaround can be remove and below assignmen used: # db.session.query.return_value.filter_by.return_value.first.return_value = attributes[1] # GIVEN db.session = AlchemyMagicMock() def workaround(): return attributes[1] db.session.query.return_value.filter_by.return_value.first = workaround # WHEN response = app.get('/v1/patients/2345') response_data = Patient(**json.loads(response.data)) # THEN assert response.status_code == 200 assert response_data.attributes.id == attributes[1].id assert response_data.attributes.first_name == attributes[1].name assert response_data.attributes.last_name == attributes[1].surname assert response_data.attributes.email == attributes[1].email assert response_data.attributes.sex == attributes[1].sex assert response_data.attributes.birthdate == attributes[1].birthdate assert response_data.links.self == 'http://localhost/v1/patients/2345' assert response_data.type == 'NP'
def test_set_templates_on_device(self, db_mock): db_mock.session = AlchemyMagicMock() json_payload = { 'templates': [{ 'import_id': 1, 'attrs': [{ 'label': 'temperature', 'type': 'dynamic', 'value_type': 'float' }] }], 'label': 'test_device', 'id': 1, 'created': '2019-08-29T18:18:07.801602+00:00' } saved_templates = [DeviceTemplate(label='test_template', attrs=[])] self.assertIsNone( ImportHandler.set_templates_on_device(Mock(), json_payload, saved_templates))
def test_close_fail_general(self, mock_create_engine, mock_update, mock_alchemy_funks): with mock.patch.dict(update_contributor.os.environ, {"Database_Location": "Djibouti"}): with mock.patch("update_contributor.Session") as mock_sesh: mock_session = AlchemyMagicMock() mock_sesh.return_value = mock_session mock_session.close.side_effect = Exception("Bad Me") mock_update.return_value.values.return_value\ .returning.return_value\ .on_conflict_do_nothing.return_value = "bob" x = update_contributor.lambda_handler( { "additional_comments": "6", # "Hello", "contributor_comments": "666", # "Contributor says hi!", "survey_period": "201712", # "201712", "survey_code": "066", # "066", "ru_reference": "77700000001" }, "") assert (x["statusCode"] == 500) assert ("Database Session Closed Badly." in x['body']['Error']) assert ("General Error" in str(x['body']['Error']))
def test_save_devices(self, db_mock): db_mock.session = AlchemyMagicMock() json_payload = { "devices": [{ "id": "68fc", "label": "test_device_0" }, { "id": "94dc", "label": "test_device_1" }] } json_data = { "devices": [{ "id": "68fc", "label": "test_device_0" }, { "id": "94dc", "label": "test_device_1" }] } saved_templates = [DeviceTemplate(label='test_template', attrs=[])] result = ImportHandler.save_devices(json_data, json_payload, saved_templates) self.assertIsNotNone(result) self.assertTrue(result)
def test_create_new_patient(app, post_request): """Should successfully save patient""" # GIVEN def set_dao_id(dao: PatientDao) -> PatientDao: dao.id = 15 return PatientDao db.session = AlchemyMagicMock() db.session.add = set_dao_id # WHEN response = app.post('/v1/patients', 'http://mock_server_url', headers=post_request['head'], data=json.dumps(post_request['body'])) response_data = Patient(**json.loads(response.data)) # THEN assert response.status_code == 200 request_data = post_request['body']['data'] assert response_data.attributes.id == 15 assert response_data.type == 'NP' assert response_data.attributes.first_name == request_data['first_name'] assert response_data.attributes.last_name == request_data['last_name'] assert response_data.attributes.email == request_data['email'] assert response_data.attributes.sex == request_data['sex'] assert response_data.links.self == 'http://mock_server_url/v1/patients/15' assert response_data.attributes.birthdate == \ get_date_from_string(request_data['birthdate'])
def test_get_multi_with_invalid_order_by_uses_default( self, mock_text, order): db_session = AlchemyMagicMock() crud.item.get_multi(db=db_session, order_by=order) mock_text.assert_has_calls([ mock.call(f"Item.id"), ]) db_session.query.assert_called()
def test_status_OK(self, mocker): session = AlchemyMagicMock() expected = {'status': 'OK'} response = Healthcheck.status(session) session.execute.assert_called_once_with("SELECT 1") assert response == expected
def test_get_multi_with_description(self, mock_text): db_session = AlchemyMagicMock() description = "Spar:" crud.item.get_multi(db=db_session, description=description) mock_text.assert_has_calls([ mock.call(f"Item.description like '%{description}%'"), ]) db_session.query.assert_called()
def test_delete_all_templates(self, db_mock): db_mock.session = AlchemyMagicMock() token = generate_token() result = TemplateHandler.delete_all_templates(token) self.assertIsNotNone(result) self.assertTrue(result) self.assertEqual(result['result'], 'ok')
def test_get_multi_with_max_val(self, mock_text): db_session = AlchemyMagicMock() max_val = 60.00 crud.item.get_multi(db=db_session, max_val=max_val) mock_text.assert_has_calls([ mock.call(f"Item.amount <= {max_val}"), ]) db_session.query.assert_called()
def test_success_coinflip(self): with app.test_request_context(): with mock.patch("flask.request", data={ "bet": 50, "side": "Heads" }): with mock.patch("server.db.session.add", AlchemyMagicMock()): response = coinflip() self.assertIs(type(response), tuple)
def test_get_multi_with_category_and_payment(self, mock_text): db_session = AlchemyMagicMock() category = [1] payment = [3, 4] crud.item.get_multi(db=db_session, category=category, payment=payment) mock_text.assert_has_calls([ mock.call(f"Item.category_id in (1) AND Item.payment_id in (3,4)"), ]) db_session.query.assert_called()
def test_invalid_url_test(self): """ Test to check whether the program responds to invalid urls :return: """ sess = AlchemyMagicMock() tiny_url = shortener.shorten(sess, "www.abcdedgskfjlkd.com") self.assertEqual("Invalid Url", tiny_url, "Invalid Url is not handled properly")
def test_get_multi_with_category_and_valid_order_by( self, mock_text, order): db_session = AlchemyMagicMock() category = [1] crud.item.get_multi(db=db_session, category=category, order_by=order) mock_text.assert_has_calls([ mock.call(f"Item.category_id in (1)"), mock.call(f"Item.{order}"), ]) db_session.query.assert_called()
def test_unique_keys(self): """ Test to check uniqueness of two different url passed :return: """ sess = AlchemyMagicMock() tiny_url_1 = shortener.shorten( sess, "https://timesofindia.indiatimes.com/defaultinterstitial.cms") tiny_url_2 = shortener.shorten(sess, "https://indiatoday.in") self.assertNotEqual(tiny_url_1, tiny_url_2, "Collision occurred")
def test_length_test(self): """ Test to check the length of tiny url :return: """ sess = AlchemyMagicMock() tiny_url = shortener.shorten( sess, "https://timesofindia.indiatimes.com/defaultinterstitial.cms") self.assertEqual(len(tiny_url), 8, "Tiny Url length is not 8")
def test_endpoint_delete_all_templates(self, db_mock): db_mock.session = AlchemyMagicMock() with self.app.test_request_context(): with patch("DeviceManager.TemplateHandler.retrieve_auth_token" ) as auth_mock: auth_mock.return_value = generate_token() result = flask_delete_all_templates() self.assertIsNotNone(result) self.assertEqual(result.status, '200 OK') self.assertEqual( json.loads(result.response[0])['result'], 'ok')
def test_get_multi_with_start_and_end_date(self, mock_text): db_session = AlchemyMagicMock() start_date = "2020-01-20" end_date = "2020-01-27" crud.item.get_multi(db=db_session, start_date=start_date, end_date=end_date) mock_text.assert_has_calls([ mock.call( f"Item.date >= '{start_date}' AND Item.date <= '{end_date}'"), ]) db_session.query.assert_called()
def test_get_multi_with_description_and_owner(self, mock_text): db_session = AlchemyMagicMock() description = "Spar:" owner_id = 1 crud.item.get_multi(db=db_session, description=description, owner_id=owner_id) mock_text.assert_has_calls([ mock.call( f"Item.description like '%{description}%' AND Item.owner_id == {owner_id}" ), ]) db_session.query.assert_called()
def test_unique_keys_for_files(self): """ Test to check uniqueness of keys from a file :return: """ sess = AlchemyMagicMock() result = shortener.shorten_from_file(sess, "./shortener/data/input.txt") unique_keys = set() for url in result: self.assertFalse(url in unique_keys, "Collision occurred") unique_keys.add(url)
def test_remove_template(self, db_mock): db_mock.session = AlchemyMagicMock() token = generate_token() template = DeviceTemplate(id=1, label='template1') with patch('DeviceManager.TemplateHandler.assert_template_exists' ) as mock_template_exist_wrapper: mock_template_exist_wrapper.return_value = template result = TemplateHandler.remove_template(1, token) self.assertIsNotNone(result) self.assertTrue(result) self.assertTrue(result['removed']) self.assertEqual(result['result'], 'ok')
def test_the_update_method_of_the_repository(): """ GIVEN the Repository class WHEN the method update(object) is called THEN check session method calls """ from app.model.repository import Repository Repository.__abstractmethods__ = frozenset() repository = Repository(object) repository.session = AlchemyMagicMock() repository.update(object) repository.session.commit.assert_called_once_with()
def test_lambda_handler_connection_close_general(self, mock_create_engine, mock_select, mock_alchemy_functions): with mock.patch.dict(get_contributor.os.environ, {"Database_Location": "MyPostgresDatase"}): with mock.patch("get_contributor.Session") as mock_sesh: mock_session = AlchemyMagicMock() mock_sesh.return_value = mock_session mock_session.close.side_effect = Exception("Bad Me") x = get_contributor.lambda_handler({"ru_reference": ""}, '') assert (x["statusCode"] == 500) assert ("Database Session Closed Badly" in x['body']['Error']) assert ("General Error" in x['body']['Error'])
def test_the_get_method_of_the_repository(app): """ GIVEN the Repository class WHEN the method get(object) is called THEN check session method calls """ from app.model.repository import Repository Repository.__abstractmethods__ = frozenset() repository = Repository(object) repository.session = AlchemyMagicMock() repository.get(object) repository.session.query.return_value.filter_by.assert_called_once_with( id=object)
def test_endpoint_get_templates(self, db_mock): db_mock.session = AlchemyMagicMock() with self.app.test_request_context(): with patch("DeviceManager.TemplateHandler.retrieve_auth_token" ) as auth_mock: auth_mock.return_value = generate_token() with patch.object(TemplateHandler, "get_templates") as mock_templates: mock_templates.return_value = { 'pagination': {}, 'templates': [] } result = flask_get_templates() self.assertEqual(result.status, '200 OK') self.assertIsNotNone(result)
def test_create_patient_double_email(app, post_request): """Should rerurn error with info about email which already exist in db""" # GIVEN def broken_function(dao): raise IntegrityError('statement', 'params', 'orig') db.session = AlchemyMagicMock() db.session.add = broken_function # WHEN response = app.post('/v1/patients', 'http://mock_server_url', headers=post_request['head'], data=json.dumps(post_request['body'])) response_data = HttpError(**json.loads(response.data)) # THEN assert response.status_code == 409 assert response_data.error.detail == 'Mail already exist'
def test_get_templates(self, db_mock): db_mock.session = AlchemyMagicMock() token = generate_token() params_query = { 'page_number': 5, 'per_page': 1, 'sortBy': None, 'attr': [], 'attr_type': [], 'label': 'dummy' } result = TemplateHandler.get_templates(params_query, token) self.assertIsNotNone(result) # test using attrs params_query = { 'page_number': 1, 'per_page': 1, 'sortBy': None, 'attr': ['foo=bar'], 'attr_type': [] } result = TemplateHandler.get_templates(params_query, token) self.assertIsNotNone(result) # test using sortBy params_query = { 'page_number': 1, 'per_page': 1, 'sortBy': 'label', 'attr': ['foo=bar'], 'attr_type': [] } result = TemplateHandler.get_templates(params_query, token) self.assertIsNotNone(result) # test without querys params_query = { 'page_number': 5, 'per_page': 1, 'sortBy': None, 'attr': [], 'attr_type': [] } result = TemplateHandler.get_templates(params_query, token) self.assertIsNotNone(result)
def test_commit_fail_general(self, mock_create_engine, mock_insert): with mock.patch.dict(create_query.os.environ, {"Database_Location": "sweden"}): with open('tests/fixtures/test_data.txt') as infile: test_data = json.load(infile) with mock.patch("create_query.Session") as mock_sesh: mock_session = AlchemyMagicMock() mock_sesh.return_value = mock_session mock_session.commit.side_effect = Exception("Bad Me") mock_insert.return_value.values.return_value\ .returning.return_value\ .on_conflict_do_nothing.return_value = "bob" x = create_query.lambda_handler(test_data, '') assert (x["statusCode"] == 500) assert ("Failed To Commit" in x['body']['Error']) assert ("General Error" in str(x['body']['Error']))
def test_lambda_handler_connection_close(self, mock_create_engine, mock_select, mock_alchemy_functions): with mock.patch.dict(get_all_reference_data.os.environ, {"Database_Location": "MyPostgresDatase"}): with mock.patch("get_all_reference_data.Session") as mock_sesh: mock_session = AlchemyMagicMock() mock_sesh.return_value = mock_session mock_session.close.side_effect =\ sqlalchemy.exc.OperationalError('', '', '') x = get_all_reference_data.lambda_handler('', '') assert (x["statusCode"] == 500) assert ("Closed Badly" in x['body']['Error']) assert ("Operational Error" in x['body']['Error'])