def init(self): '''This method setup common dependencies for all test cases: query_parser''' self._query_parser = QueryParser()
class QueryParserTests(FantasticoUnitTestsCase): '''This class provides the tests cases for query parser.''' _query_parser = None def init(self): '''This method setup common dependencies for all test cases: query_parser''' self._query_parser = QueryParser() def test_parse_filter_empty(self): '''This test case ensures None is returned for an empty filter passed as argument.''' filters = [None, "", " "] model = Mock() for filter_expr in filters: result = self._query_parser.parse_filter(filter_expr, model) self.assertIsNone(result) def test_parse_filter_binary_invalidcolumn(self): '''This test case ensures an exception is raised if a column name not found in the model is given for binary operations.''' filter_expr = "eq(not_supported, vat)" with self.assertRaises(FantasticoRoaError) as ctx: self._query_parser.parse_filter(filter_expr, AppSettingMock) self.assertTrue(str(ctx.exception).find("not_supported") > -1) def test_parse_filter_binary_notenougharguments(self): '''This test case ensures an exception is raised if a binary operation does not receive enough arguments.''' filters = ["eq()", "eq(a,)", "eq(,b)"] for filter_expr in filters: with self.assertRaises(FantasticoRoaError) as ctx: self._query_parser.parse_filter(filter_expr, Mock()) self.assertTrue(str(ctx.exception).find("eq") > -1) def test_parse_filter_invalidoperation(self): '''This test case ensures an exception is raised when the given operation is not found.''' filter_expr = "invalid_operation(a, b)" with self.assertRaises(FantasticoRoaError): self._query_parser.parse_filter(filter_expr, Mock()) def _test_parse_binary_filter(self, filter_expr, expected_column, expected_value, expected_operation): '''This is a template method for executing test cases against binary operation: eq, like, gt, ge, lt, le, in.''' result = self._query_parser.parse_filter(filter_expr, AppSettingMock) self.assertIsInstance(result, ModelFilter) self.assertEqual(result.column, expected_column) self.assertEqual(result.ref_value, expected_value) self.assertEqual(result.operation, expected_operation) def test_parse_filter_eq(self): '''This test case ensures an equality filter can be parsed to a query object.''' filter_expr = "eq(name , \"vat\")" self._test_parse_binary_filter(filter_expr, AppSettingMock.name, "vat", ModelFilter.EQ) def test_parse_filter_like(self): '''This test case ensures like operation is correctly parsed''' filter_expr = "like (name , \"%vat%\" )" self._test_parse_binary_filter(filter_expr, AppSettingMock.name, "%vat%", ModelFilter.LIKE) def test_parse_filter_gt(self): '''This test case ensures greater than operation is correctly parsed.''' filter_expr = "gt(value, 0.19)" self._test_parse_binary_filter(filter_expr, AppSettingMock.value, 0.19, ModelFilter.GT) def test_parse_filter_ge(self): '''This test case ensures greater or equal than operation is correctly parsed.''' filter_expr = "ge(value, 0.19)" self._test_parse_binary_filter(filter_expr, AppSettingMock.value, 0.19, ModelFilter.GE) def test_parse_filter_lt(self): '''This test case ensures less than operation is correctly parsed.''' filter_expr = "lt(value, 0.19)" self._test_parse_binary_filter(filter_expr, AppSettingMock.value, 0.19, ModelFilter.LT) def test_parse_filter_le(self): '''This test case ensures less or equal than operation is correctly parsed.''' filter_expr = "le(value, 0.19)" self._test_parse_binary_filter(filter_expr, AppSettingMock.value, 0.19, ModelFilter.LE) def test_parse_filter_in(self): '''This test case ensures in operation is correctly parsed.''' filter_expr = "in(value, [0.19, 0.20, 0.21])" self._test_parse_binary_filter(filter_expr, AppSettingMock.value, [0.19, 0.20, 0.21], ModelFilter.IN) def test_parse_filter_compoundor(self): '''This test case ensures compound or operations is correctly parsed.''' filter_expr = "or(eq(name, \"vat\"), eq(value, \"en_US\"))" result = self._query_parser.parse_filter(filter_expr, AppSettingMock) self.assertIsInstance(result, ModelFilterOr) result_filters = result.model_filters self.assertEqual(len(result_filters), 2) self.assertIsInstance(result_filters[0], ModelFilter) self.assertEqual(result_filters[0].column, AppSettingMock.name) self.assertEqual(result_filters[0].ref_value, "vat") self.assertEqual(result_filters[0].operation, ModelFilter.EQ) self.assertIsInstance(result_filters[1], ModelFilter) self.assertEqual(result_filters[1].column, AppSettingMock.value) self.assertEqual(result_filters[1].ref_value, "en_US") self.assertEqual(result_filters[1].operation, ModelFilter.EQ) def test_parse_filter_compoundand(self): '''This test case ensures compound or operations is correctly parsed.''' filter_expr = "and(eq(name, \"vat\"), eq(value, \"en_US\"))" result = self._query_parser.parse_filter(filter_expr, AppSettingMock) self.assertIsInstance(result, ModelFilterAnd) result_filters = result.model_filters self.assertEqual(len(result_filters), 2) self.assertIsInstance(result_filters[0], ModelFilter) self.assertEqual(result_filters[0].column, AppSettingMock.name) self.assertEqual(result_filters[0].ref_value, "vat") self.assertEqual(result_filters[0].operation, ModelFilter.EQ) self.assertIsInstance(result_filters[1], ModelFilter) self.assertEqual(result_filters[1].column, AppSettingMock.value) self.assertEqual(result_filters[1].ref_value, "en_US") self.assertEqual(result_filters[1].operation, ModelFilter.EQ) def test_parse_filter_compoundand_with_or(self): '''This test case ensures compound filters can receive other compound filters as argument.''' filter_expr = "and(or(eq(name, \"vat\"), eq(name, \"locale\")), eq(name, \"vat\"))" result = self._query_parser.parse_filter(filter_expr, AppSettingMock) self.assertIsInstance(result, ModelFilterAnd) result_filters = result.model_filters self.assertEqual(len(result_filters), 2) result_or = result_filters[0] result_eq = result_filters[1] self.assertIsInstance(result_or, ModelFilterOr) self.assertIsInstance(result_eq, ModelFilter) self.assertEqual(result_eq.column, AppSettingMock.name) self.assertEqual(result_eq.ref_value, "vat") self.assertEqual(result_eq.operation, ModelFilter.EQ) def test_parse_filter_compound_notenoughargs(self): '''This test case ensures an exception is raised when not enough arguments are passed to **or** filter.''' filters = ["or()", "or(,)", "or ( )"] for filter_expr in filters: with self.assertRaises(QueryParserOperationInvalidError) as ctx: self._query_parser.parse_filter(filter_expr, Mock()) self.assertTrue(str(ctx.exception).find("or ") > -1) def test_parse_filter_compound_invalidarg(self): '''This test case ensures an exception is raised if an invalid argument is passed to a compound filter.''' filter_expr = "or(eq(), eq(a,b))" with self.assertRaises(QueryParserOperationInvalidError) as ctx: self._query_parser.parse_filter(filter_expr, AppSettingMock) self.assertTrue(str(ctx.exception).find("eq") > -1) def test_parse_sort_empty(self): '''This test case ensures an empty list is returned for empty sort expressions.''' sort_expr = [] self.assertEqual(self._query_parser.parse_sort(sort_expr, Mock()), []) def _test_parse_sort(self, sort_expr, expected_col, expected_dir): '''This method provides a template for testing simple sort filters.''' results = self._query_parser.parse_sort(sort_expr, AppSettingMock) self.assertEqual(len(results), 1) result = results[0] self.assertIsInstance(result, ModelSort) self.assertEqual(result.column, expected_col) self.assertEqual(result.sort_dir, expected_dir) def test_parse_sort_asc(self): '''This test case ensures sort ascending is parsed correctly.''' sort_expr = ["asc(name)"] self._test_parse_sort(sort_expr, AppSettingMock.name, ModelSort.ASC) def test_parse_sort_desc(self): '''This test case ensures sort descending is parsed correctly.''' sort_expr = ["desc(name)"] self._test_parse_sort(sort_expr, AppSettingMock.name, ModelSort.DESC) def test_parse_sort_invalidarg(self): '''This test case ensures invalid argument passed into sort expressions fail.''' sort_expr = ["asc(not_found)"] with self.assertRaises(FantasticoRoaError) as ctx: self._query_parser.parse_sort(sort_expr, AppSettingMock) self.assertTrue(str(ctx.exception).find(" not_found ") > -1)