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'])