def test_get_paged_records_ok(self):
'''This test case ensures records can be retrieved correctly from a facade.'''
expected_model = Mock()
self._model_filter = ModelFilter(PersonModelTest.id, 1, ModelFilter.GT)
self._model_sort = ModelSort(PersonModelTest.first_name)
def query_mock(cls_obj):
self.assertEqual(PersonModelTest, cls_obj)
return self._session
def filter_mock(expr):
self.assertEqual(self._model_filter.get_expression(), expr)
return self._session
def sort_mock(expr):
self.assertEqual(self._model_sort.get_expression(), expr)
return self._session
def offset_mock(offset):
self.assertEqual(0, offset)
return self._session
def limit_mock(limit_count):
self.assertEqual(4, limit_count)
return self._session
self._session.query = query_mock
self._session._primary_entity = self._session
self._session.selectable = PersonModelTest.id.table
self._session.filter = filter_mock
self._session.order_by = sort_mock
self._session.offset = offset_mock
self._session.limit = limit_mock
self._session.all = Mock(
return_value=[expected_model, expected_model, expected_model])
records = self._facade.get_records_paged(
start_record=0,
end_record=4,
sort_expr=self._model_sort,
filter_expr=self._model_filter)
self.assertIsNotNone(records)
self.assertEqual(3, len(records))
for model in records:
self.assertEqual(expected_model, model)
def test_modelsort_ok(self):
'''This test case ensures modelsort filter is correctly built.'''
expected_result = Mock()
query = Mock()
query._primary_entity = query
query._primary_entity.selectable = self._id_col.table
query.order_by = Mock(return_value=expected_result)
for sort_dir in ModelSort.get_supported_sort_dirs(self):
model_sort = ModelSort(self._id_col, sort_dir)
new_query = model_sort.build(query)
self.assertEqual(self._id_col, model_sort.column)
self.assertEqual(sort_dir, model_sort.sort_dir)
self.assertEqual(expected_result, new_query)
def test_modelsort_ok(self):
'''This test case ensures modelsort filter is correctly built.'''
expected_result = Mock()
query = Mock()
query._primary_entity = query
query._primary_entity.selectable = self._id_col.table
query.order_by = Mock(return_value=expected_result)
for sort_dir in ModelSort.get_supported_sort_dirs(self):
model_sort = ModelSort(self._id_col, sort_dir)
new_query = model_sort.build(query)
self.assertEqual(self._id_col, model_sort.column)
self.assertEqual(sort_dir, model_sort.sort_dir)
self.assertEqual(expected_result, new_query)
def test_get_paged_records_ok(self):
'''This test case ensures records can be retrieved correctly from a facade.'''
expected_model = Mock()
self._model_filter = ModelFilter(PersonModelTest.id, 1, ModelFilter.GT)
self._model_sort = ModelSort(PersonModelTest.first_name)
def query_mock(cls_obj):
self.assertEqual(PersonModelTest, cls_obj)
return self._session
def filter_mock(expr):
self.assertEqual(self._model_filter.get_expression(), expr)
return self._session
def sort_mock(expr):
self.assertEqual(self._model_sort.get_expression(), expr)
return self._session
def offset_mock(offset):
self.assertEqual(0, offset)
return self._session
def limit_mock(limit_count):
self.assertEqual(4, limit_count)
return self._session
self._session.query = query_mock
self._session._primary_entity = self._session
self._session.selectable = PersonModelTest.id.table
self._session.filter = filter_mock
self._session.order_by = sort_mock
self._session.offset = offset_mock
self._session.limit = limit_mock
self._session.all = Mock(return_value=[expected_model, expected_model, expected_model])
records = self._facade.get_records_paged(start_record=0, end_record=4,
sort_expr=self._model_sort,
filter_expr=self._model_filter)
self.assertIsNotNone(records)
self.assertEqual(3, len(records))
for model in records:
self.assertEqual(expected_model, model)
def test_retrieve_subset_ordered_asc_in(self):
'''This test case ensures a subset of records is retrieved correctly when order expression and in
filter are specified.'''
model_filter_in = ModelFilter(ModelFacadeMessage.message,
["Hello world 2", "Hello world 3"],
ModelFilter.IN)
model_sort = ModelSort(ModelFacadeMessage.message, ModelSort.ASC)
records = self.model_facade.get_records_paged(
1, 2, filter_expr=model_filter_in, sort_expr=model_sort)
self.assertIsNotNone(records)
self.assertEqual(1, len(records))
self.assertEqual(self.MESSAGES[-2], records[0].message)
def test_retrieve_subset_ordered_asc(self):
'''This test case ensures subset records retrieval work as expected for asc order.'''
model_filter_like = ModelFilter(ModelFacadeMessage.message,
"%%world%%", ModelFilter.LIKE)
model_sort = ModelSort(ModelFacadeMessage.message, ModelSort.ASC)
records = self.model_facade.get_records_paged(
1, 3, filter_expr=model_filter_like, sort_expr=model_sort)
self.assertIsNotNone(records)
self.assertEqual(2, len(records))
self.assertEqual(self.MESSAGES[1], records[0].message)
self.assertEqual(self.MESSAGES[2], records[1].message)
self.assertLess(records[0].id, records[1].id)
def test_modelsort_col_notsupported(self):
'''This test case ensures an exception is raised if the given column type is not supported.'''
with self.assertRaises(FantasticoNotSupportedError):
ModelSort(Mock(), ModelSort.ASC)
def test_modelsort_dir_notsupported(self):
'''This test case ensures an exception is raised if model sort given direction is not supported.'''
with self.assertRaises(FantasticoNotSupportedError):
ModelSort(self._id_col, "xxx")
class ModelFacadeTests(FantasticoUnitTestsCase):
'''This class provides test suite for generating a model facade for BaseModel classes.'''
def init(self):
self._session = Mock()
self._facade = ModelFacade(PersonModelTest, self._session)
self._rollbacked = False
self._model_filter = None
self._model_sort = None
def test_new_model_ok(self):
'''This test case ensures a model facade can obtain an instance of a given class.'''
for model in [
self._facade.new_model("John", **{"last_name": "Doe"}),
self._facade.new_model("John", last_name="Doe")
]:
self.assertEqual(PersonModelTest, self._facade.model_cls)
self.assertIsInstance(model, BASEMODEL)
self.assertEqual("John", model.first_name)
self.assertEqual("Doe", model.last_name)
def test_new_model_incompatible(self):
'''This test case makes sure a model facade instance raises an exception if given model class does not
extend **BASEMODEL**.'''
with self.assertRaises(FantasticoIncompatibleClassError):
ModelFacade(Mock(), Mock())
def test_create_ok(self):
'''This test case makes sure a model can be correctly saved using a facade.'''
model = PersonModelTest(first_name="John", last_name="Doe")
def add(model):
model.id = 1
return self._session
self._session.add = add
model_id = self._facade.create(model)
self.assertFalse(self._rollbacked)
self.assertEqual(1, len(model_id))
self.assertEqual(1, model_id[0])
self.assertEqual(1, model.id)
def test_create_exception_unhandled(self):
'''This test case makes sure a model creation exception is wrapped correctly into a concrete fantastico exception.'''
model = PersonModelTest(first_name="John", last_name="Doe")
self._session.add = Mock(side_effect=Exception("Unhandled exception"))
def rollback():
self._rollbacked = True
self._session.rollback = rollback
self.assertRaises(FantasticoDbError, self._facade.create, *[model])
self.assertTrue(self._rollbacked)
def test_update_ok(self):
'''This test case ensures a model can be updated correctly using model facade.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._session.query = Mock(return_value=self._session)
self._session.filter = Mock(return_value=self._session)
self._session.all = Mock(return_value=[model])
def merge(model):
model.first_name = "John Changed"
self._session.merge = merge
self._facade.update(model)
self.assertFalse(self._rollbacked)
self.assertEqual("John Changed", model.first_name)
def test_update_exception_unhandled(self):
'''This test case ensures a model update gracefully handles all unhandled exceptions.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._session.query = Mock(return_value=self._session)
self._session.filter = Mock(return_value=self._session)
self._session.all = Mock(return_value=[model])
self._session.merge = Mock(
side_effect=Exception("Unhandled exception"))
def rollback():
self._rollbacked = True
self._session.rollback = rollback
self.assertRaises(FantasticoDbError, self._facade.update, *[model])
self.assertTrue(self._rollbacked)
def test_update_exception_notfound(self):
'''This test case ensures a model update exception is raised when the given model does not exist.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._session.query = Mock(return_value=self._session)
self._session.filter = Mock(return_value=self._session)
self._session.all = Mock(return_value=[])
def rollback():
self._rollbacked = True
self._session.rollback = rollback
self.assertRaises(FantasticoDbNotFoundError, self._facade.update,
*[model])
self.assertTrue(self._rollbacked)
def test_find_by_pk_ok(self):
'''This test case ensures find_by_pk method retrieves a model instance when a record is found by id.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._session.query = Mock(return_value=self._session)
self._session.filter = Mock(return_value=self._session)
self._session.all = Mock(return_value=[model])
response = self._facade.find_by_pk({PersonModelTest.id: 1})
self.assertFalse(self._rollbacked)
self.assertEqual(model, response)
def test_find_by_pk_notfound(self):
'''This test case ensures find_by_pk method raises an exception when a matching record is not found.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._session.query = Mock(return_value=self._session)
self._session.filter = Mock(return_value=self._session)
self._session.all = Mock(return_value=[])
def rollback():
self._rollbacked = True
self._session.rollback = rollback
with self.assertRaises(FantasticoDbNotFoundError):
self._facade.find_by_pk({PersonModelTest.id: 1})
self.assertTrue(self._rollbacked)
def test_delete_ok(self):
'''This test case ensures a model can be deleted successfully if no exception occurs.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._facade.delete(model)
self.assertFalse(self._rollbacked)
def test_delete_exception_unhandled(self):
'''This test case ensures unhandled exceptions are gracefully handled by delete method.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._session.delete = Mock(
side_effect=Exception("Unhandled exception"))
def rollback():
self._rollbacked = True
self._session.rollback = rollback
with self.assertRaises(FantasticoDbError):
self._facade.delete(model)
self.assertTrue(self._rollbacked)
def test_get_paged_records_ok(self):
'''This test case ensures records can be retrieved correctly from a facade.'''
expected_model = Mock()
self._model_filter = ModelFilter(PersonModelTest.id, 1, ModelFilter.GT)
self._model_sort = ModelSort(PersonModelTest.first_name)
def query_mock(cls_obj):
self.assertEqual(PersonModelTest, cls_obj)
return self._session
def filter_mock(expr):
self.assertEqual(self._model_filter.get_expression(), expr)
return self._session
def sort_mock(expr):
self.assertEqual(self._model_sort.get_expression(), expr)
return self._session
def offset_mock(offset):
self.assertEqual(0, offset)
return self._session
def limit_mock(limit_count):
self.assertEqual(4, limit_count)
return self._session
self._session.query = query_mock
self._session._primary_entity = self._session
self._session.selectable = PersonModelTest.id.table
self._session.filter = filter_mock
self._session.order_by = sort_mock
self._session.offset = offset_mock
self._session.limit = limit_mock
self._session.all = Mock(
return_value=[expected_model, expected_model, expected_model])
records = self._facade.get_records_paged(
start_record=0,
end_record=4,
sort_expr=self._model_sort,
filter_expr=self._model_filter)
self.assertIsNotNone(records)
self.assertEqual(3, len(records))
for model in records:
self.assertEqual(expected_model, model)
def test_get_records_paged_default(self):
'''This test case ensure records are retrieved when no filter / sort_expr are specified.'''
def query_mock(cls_obj):
self.assertEqual(PersonModelTest, cls_obj)
return self._session
def offset_mock(offset):
self.assertEqual(0, offset)
return self._session
def limit_mock(limit_count):
self.assertEqual(4, limit_count)
return self._session
self._session.query = query_mock
self._session.offset = offset_mock
self._session.limit = limit_mock
self._session.all = Mock(return_value=[])
records = self._facade.get_records_paged(start_record=0, end_record=4)
self.assertIsNotNone(records)
self.assertEqual(0, len(records))
def test_get_records_paged_unhandled_exception(self):
'''This test case ensures that any unhandled exception from filters / sql alchemy is gracefully handled.'''
self._model_filter = ModelFilter(PersonModelTest.id, 1, ModelFilter.GT)
self._model_filter.build = Mock(
side_effect=Exception("Unhandled exception"))
def rollback():
self._rollbacked = True
self._session.rollback = rollback
with self.assertRaises(FantasticoDbError):
self._facade.get_records_paged(start_record=0,
end_record=4,
filter_expr=self._model_filter)
self.assertTrue(self._rollbacked)
def test_count_records_default_ok(self):
'''This test case ensures count method works correctly.'''
def query_mock(cls_obj):
self.assertEqual(PersonModelTest, cls_obj)
return self._session
self._session.query = query_mock
self._session.count = Mock(return_value=20)
records_count = self._facade.count_records()
self.assertEqual(20, records_count)
def test_count_records_filtered_ok(self):
'''This test case ensures count method works correctly when a filter is given.'''
self._model_filter = ModelFilter(PersonModelTest.id, 1, ModelFilter.GT)
def query_mock(cls_obj):
self.assertEqual(PersonModelTest, cls_obj)
return self._session
def filter_mock(expr):
self.assertEqual(self._model_filter.get_expression(), expr)
return self._session
self._session.query = query_mock
self._session._primary_entity = self._session
self._session.selectable = PersonModelTest.id.table
self._session.filter = filter_mock
self._session.count = Mock(return_value=20)
records_count = self._facade.count_records(self._model_filter)
self.assertEqual(20, records_count)
def test_count_records_unhandled_exception(self):
'''This test case ensures count method gracefully handles unexpected exceptions.'''
self._model_filter = ModelFilter(PersonModelTest.id, 1, ModelFilter.GT)
self._model_filter.build = Mock(
side_effect=Exception("Unhandled exception"))
def rollback():
self._rollbacked = True
self._session.rollback = rollback
with self.assertRaises(FantasticoDbError):
self._facade.count_records(self._model_filter)
self.assertTrue(self._rollbacked)
def build_filter(self, model):
'''This method builds the sorting model.'''
return ModelSort(self._argument, self._sort_dir)
class ModelFacadeTests(FantasticoUnitTestsCase):
'''This class provides test suite for generating a model facade for BaseModel classes.'''
def init(self):
self._session = Mock()
self._facade = ModelFacade(PersonModelTest, self._session)
self._rollbacked = False
self._model_filter = None
self._model_sort = None
def test_new_model_ok(self):
'''This test case ensures a model facade can obtain an instance of a given class.'''
for model in [self._facade.new_model("John", **{"last_name": "Doe"}),
self._facade.new_model("John", last_name="Doe")]:
self.assertEqual(PersonModelTest, self._facade.model_cls)
self.assertIsInstance(model, BASEMODEL)
self.assertEqual("John", model.first_name)
self.assertEqual("Doe", model.last_name)
def test_new_model_incompatible(self):
'''This test case makes sure a model facade instance raises an exception if given model class does not
extend **BASEMODEL**.'''
with self.assertRaises(FantasticoIncompatibleClassError):
ModelFacade(Mock(), Mock())
def test_create_ok(self):
'''This test case makes sure a model can be correctly saved using a facade.'''
model = PersonModelTest(first_name="John", last_name="Doe")
def add(model):
model.id = 1
return self._session
self._session.add = add
model_id = self._facade.create(model)
self.assertFalse(self._rollbacked)
self.assertEqual(1, len(model_id))
self.assertEqual(1, model_id[0])
self.assertEqual(1, model.id)
def test_create_exception_unhandled(self):
'''This test case makes sure a model creation exception is wrapped correctly into a concrete fantastico exception.'''
model = PersonModelTest(first_name="John", last_name="Doe")
self._session.add = Mock(side_effect=Exception("Unhandled exception"))
def rollback():
self._rollbacked = True
self._session.rollback = rollback
self.assertRaises(FantasticoDbError, self._facade.create, *[model])
self.assertTrue(self._rollbacked)
def test_update_ok(self):
'''This test case ensures a model can be updated correctly using model facade.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._session.query = Mock(return_value=self._session)
self._session.filter = Mock(return_value=self._session)
self._session.all = Mock(return_value=[model])
def merge(model):
model.first_name = "John Changed"
self._session.merge = merge
self._facade.update(model)
self.assertFalse(self._rollbacked)
self.assertEqual("John Changed", model.first_name)
def test_update_exception_unhandled(self):
'''This test case ensures a model update gracefully handles all unhandled exceptions.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._session.query = Mock(return_value=self._session)
self._session.filter = Mock(return_value=self._session)
self._session.all = Mock(return_value=[model])
self._session.merge = Mock(side_effect=Exception("Unhandled exception"))
def rollback():
self._rollbacked = True
self._session.rollback = rollback
self.assertRaises(FantasticoDbError, self._facade.update, *[model])
self.assertTrue(self._rollbacked)
def test_update_exception_notfound(self):
'''This test case ensures a model update exception is raised when the given model does not exist.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._session.query = Mock(return_value=self._session)
self._session.filter = Mock(return_value=self._session)
self._session.all = Mock(return_value=[])
def rollback():
self._rollbacked = True
self._session.rollback = rollback
self.assertRaises(FantasticoDbNotFoundError, self._facade.update, *[model])
self.assertTrue(self._rollbacked)
def test_find_by_pk_ok(self):
'''This test case ensures find_by_pk method retrieves a model instance when a record is found by id.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._session.query = Mock(return_value=self._session)
self._session.filter = Mock(return_value=self._session)
self._session.all = Mock(return_value=[model])
response = self._facade.find_by_pk({PersonModelTest.id: 1})
self.assertFalse(self._rollbacked)
self.assertEqual(model, response)
def test_find_by_pk_notfound(self):
'''This test case ensures find_by_pk method raises an exception when a matching record is not found.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._session.query = Mock(return_value=self._session)
self._session.filter = Mock(return_value=self._session)
self._session.all = Mock(return_value=[])
def rollback():
self._rollbacked = True
self._session.rollback = rollback
with self.assertRaises(FantasticoDbNotFoundError):
self._facade.find_by_pk({PersonModelTest.id: 1})
self.assertTrue(self._rollbacked)
def test_delete_ok(self):
'''This test case ensures a model can be deleted successfully if no exception occurs.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._facade.delete(model)
self.assertFalse(self._rollbacked)
def test_delete_exception_unhandled(self):
'''This test case ensures unhandled exceptions are gracefully handled by delete method.'''
model = PersonModelTest(first_name="John", last_name="Doe")
model.id = 1
self._session.delete = Mock(side_effect=Exception("Unhandled exception"))
def rollback():
self._rollbacked = True
self._session.rollback = rollback
with self.assertRaises(FantasticoDbError):
self._facade.delete(model)
self.assertTrue(self._rollbacked)
def test_get_paged_records_ok(self):
'''This test case ensures records can be retrieved correctly from a facade.'''
expected_model = Mock()
self._model_filter = ModelFilter(PersonModelTest.id, 1, ModelFilter.GT)
self._model_sort = ModelSort(PersonModelTest.first_name)
def query_mock(cls_obj):
self.assertEqual(PersonModelTest, cls_obj)
return self._session
def filter_mock(expr):
self.assertEqual(self._model_filter.get_expression(), expr)
return self._session
def sort_mock(expr):
self.assertEqual(self._model_sort.get_expression(), expr)
return self._session
def offset_mock(offset):
self.assertEqual(0, offset)
return self._session
def limit_mock(limit_count):
self.assertEqual(4, limit_count)
return self._session
self._session.query = query_mock
self._session._primary_entity = self._session
self._session.selectable = PersonModelTest.id.table
self._session.filter = filter_mock
self._session.order_by = sort_mock
self._session.offset = offset_mock
self._session.limit = limit_mock
self._session.all = Mock(return_value=[expected_model, expected_model, expected_model])
records = self._facade.get_records_paged(start_record=0, end_record=4,
sort_expr=self._model_sort,
filter_expr=self._model_filter)
self.assertIsNotNone(records)
self.assertEqual(3, len(records))
for model in records:
self.assertEqual(expected_model, model)
def test_get_records_paged_default(self):
'''This test case ensure records are retrieved when no filter / sort_expr are specified.'''
def query_mock(cls_obj):
self.assertEqual(PersonModelTest, cls_obj)
return self._session
def offset_mock(offset):
self.assertEqual(0, offset)
return self._session
def limit_mock(limit_count):
self.assertEqual(4, limit_count)
return self._session
self._session.query = query_mock
self._session.offset = offset_mock
self._session.limit = limit_mock
self._session.all = Mock(return_value=[])
records = self._facade.get_records_paged(start_record=0, end_record=4)
self.assertIsNotNone(records)
self.assertEqual(0, len(records))
def test_get_records_paged_unhandled_exception(self):
'''This test case ensures that any unhandled exception from filters / sql alchemy is gracefully handled.'''
self._model_filter = ModelFilter(PersonModelTest.id, 1, ModelFilter.GT)
self._model_filter.build = Mock(side_effect=Exception("Unhandled exception"))
def rollback():
self._rollbacked = True
self._session.rollback = rollback
with self.assertRaises(FantasticoDbError):
self._facade.get_records_paged(start_record=0, end_record=4, filter_expr=self._model_filter)
self.assertTrue(self._rollbacked)
def test_count_records_default_ok(self):
'''This test case ensures count method works correctly.'''
def query_mock(cls_obj):
self.assertEqual(PersonModelTest, cls_obj)
return self._session
self._session.query = query_mock
self._session.count = Mock(return_value=20)
records_count = self._facade.count_records()
self.assertEqual(20, records_count)
def test_count_records_filtered_ok(self):
'''This test case ensures count method works correctly when a filter is given.'''
self._model_filter = ModelFilter(PersonModelTest.id, 1, ModelFilter.GT)
def query_mock(cls_obj):
self.assertEqual(PersonModelTest, cls_obj)
return self._session
def filter_mock(expr):
self.assertEqual(self._model_filter.get_expression(), expr)
return self._session
self._session.query = query_mock
self._session._primary_entity = self._session
self._session.selectable = PersonModelTest.id.table
self._session.filter = filter_mock
self._session.count = Mock(return_value=20)
records_count = self._facade.count_records(self._model_filter)
self.assertEqual(20, records_count)
def test_count_records_unhandled_exception(self):
'''This test case ensures count method gracefully handles unexpected exceptions.'''
self._model_filter = ModelFilter(PersonModelTest.id, 1, ModelFilter.GT)
self._model_filter.build = Mock(side_effect=Exception("Unhandled exception"))
def rollback():
self._rollbacked = True
self._session.rollback = rollback
with self.assertRaises(FantasticoDbError):
self._facade.count_records(self._model_filter)
self.assertTrue(self._rollbacked)