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_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_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")
def build_filter(self, model):
'''This method builds the sorting model.'''
return ModelSort(self._argument, self._sort_dir)
