def test_modelfilterand_ok(self): '''This test case ensures compound **and** filter correctly transform the filter into sql alchemy and_ statement.''' self._or_invoked = False model_filter = ModelFilterAnd(ModelFilter(self._model.id, 1, ModelFilter.EQ), ModelFilter(self._model.id, 1, ModelFilter.EQ), ModelFilter(self._model.id, 1, ModelFilter.EQ)) query = Mock() def filter_fn(expr): self._or_invoked = True return Mock() self._model.id.table = Mock() query._primary_entity = query query.selectable = self._model.id.table query.filter = filter_fn query_new = model_filter.build(query) self.assertTrue(self._or_invoked) self.assertIsInstance(query_new, Mock)
def test_modelfilterand_ok(self): '''This test case ensures compound **and** filter correctly transform the filter into sql alchemy and_ statement.''' self._or_invoked = False model_filter = ModelFilterAnd( ModelFilter(self._model.id, 1, ModelFilter.EQ), ModelFilter(self._model.id, 1, ModelFilter.EQ), ModelFilter(self._model.id, 1, ModelFilter.EQ)) query = Mock() def filter_fn(expr): self._or_invoked = True return Mock() self._model.id.table = Mock() query._primary_entity = query query.selectable = self._model.id.table query.filter = filter_fn query_new = model_filter.build(query) self.assertTrue(self._or_invoked) self.assertIsInstance(query_new, Mock)
def test_modelfiterand_unhandled_exception(self): '''This test case ensures unhandled exceptions raised from ModelFilter are gracefully handled by ModelFilterAnd build.''' model_filter = ModelFilter(self._model.id, 1, ModelFilter.EQ) model_filter.get_expression = Mock(side_effect=Exception("Unhandled exception")) model_filter_and = ModelFilterAnd(model_filter, model_filter, model_filter) with self.assertRaises(FantasticoError): model_filter_and.build(Mock())
def test_modelfiterand_unhandled_exception(self): '''This test case ensures unhandled exceptions raised from ModelFilter are gracefully handled by ModelFilterAnd build.''' model_filter = ModelFilter(self._model.id, 1, ModelFilter.EQ) model_filter.get_expression = Mock( side_effect=Exception("Unhandled exception")) model_filter_and = ModelFilterAnd(model_filter, model_filter, model_filter) with self.assertRaises(FantasticoError): model_filter_and.build(Mock())
def test_modelfilterand_eq_ok(self): '''This test case ensures two model filters and equality works as expected.''' id_col = Column("id", Integer) name_col = Column("name", String(100)) filter1 = ModelFilterAnd(ModelFilter(id_col, 1, ModelFilter.EQ), ModelFilter(name_col, "john", ModelFilter.EQ)) filter2 = ModelFilterAnd(ModelFilter(id_col, 1, ModelFilter.EQ), ModelFilter(name_col, "john", ModelFilter.EQ)) self.assertEqual(filter1, filter2) self.assertEqual(hash(filter1), hash(filter2))
def test_modelfilterand_eq_different(self): '''This test case ensures compound model filter and is not always equal with another compound model filter and.''' id_col = Column("id", Integer) name_col = Column("name", String(100)) filter1 = ModelFilterAnd(ModelFilter(id_col, 1, ModelFilter.EQ), ModelFilter(id_col, 1, ModelFilter.EQ)) filter2 = ModelFilterAnd(ModelFilter(id_col, 1, ModelFilter.EQ), ModelFilter(name_col, "john", ModelFilter.EQ)) self.assertNotEqual(filter1, filter2) self.assertNotEqual(hash(filter1), hash(filter2))
def test_modelfilterand_eq_differenttype(self): '''This test case ensures compound model filter and can not be equal with a simple model filter.''' id_col = Column("id", Integer) name_col = Column("name", String(100)) filter1 = ModelFilter(id_col, 1, ModelFilter.EQ) filter2 = ModelFilterAnd(filter1, ModelFilter(name_col, "john", ModelFilter.EQ)) self.assertNotEqual(filter2, filter1) self.assertNotEqual(hash(filter2), hash(filter1))
def test_retrieve_message_byfilter_and(self): '''This test case ensures filtering message using compound **and** works as expected.''' model_filter_gt = ModelFilter(ModelFacadeMessage.id, 1, ModelFilter.GT) model_filter_like = ModelFilter(ModelFacadeMessage.message, "%%world 4%%", ModelFilter.LIKE) model_filter_and = ModelFilterAnd(model_filter_gt, model_filter_like) records = self.model_facade.get_records_paged( 0, 100, filter_expr=model_filter_and) self.assertEqual(1, len(records)) self.assertEqual(self.last_generated_pk, records[0].id) self.assertEqual(self.MESSAGES[-1], records[0].message)
def _validate_return_url(self, clienturls_facade, return_url): '''This test case checks the existence of return url in the list of supported return urls for idp.''' qmark_pos = return_url.find("?") if qmark_pos > -1: return_url = return_url[:qmark_pos] client_urls = clienturls_facade.get_records_paged( start_record=0, end_record=1, filter_expr=ModelFilterAnd( ModelFilter(ClientReturnUrl.client_id, self._idp_client_id, ModelFilter.EQ), ModelFilter(ClientReturnUrl.return_url, return_url, ModelFilter.EQ))) if len(client_urls) != 1: raise OAuth2MissingQueryParamError(self.REDIRECT_PARAM)
def test_authenticate_invalid_redirecturi(self): '''This test case ensures an exception is raised when the return url query parameter is not accepted by idp.''' creation_time, expiration_time = self._mock_creationexpiration_time() user = User(username="******", password="******") user.session = Mock() return_url = "/test/url?state=xyz" token = Token({ "client_id": self._IDP_CLIENTID, "type": "login", "user_id": user.user_id, "creation_time": creation_time, "expiration_time": expiration_time }) request, user_repo_cls, user_repo, tokens_service_cls, \ tokens_service, clienturl_facade = self._mock_authenticate_dependencies(token, user, return_url) clienturl_facade.get_records_paged = Mock(return_value=[]) with self.assertRaises(OAuth2MissingQueryParamError): self._idp_controller.authenticate( request, tokens_service_cls=tokens_service_cls, user_repo_cls=user_repo_cls) return_url = return_url[:return_url.find("?")] clienturl_facade.get_records_paged.assert_called_once_with( start_record=0, end_record=1, filter_expr=ModelFilterAnd( ModelFilter(ClientReturnUrl.client_id, self._IDP_CLIENTID, ModelFilter.EQ), ModelFilter(ClientReturnUrl.return_url, return_url, ModelFilter.EQ)))
def get_collection(self, request, version, resource_url): '''This method provides the route for accessing a resource collection. :doc:`/features/roa/rest_standard` for collections are enabled by this method. The typical response format is presented below: .. code-block:: javascript var response = {"items": [ // resources represented as json objects. ], "totalItems": 100} If a resource is not found or the resource version does not exist the following response is returned: .. code-block:: javascript {"error_code": 10000, "error_description": "Resource %s version %s does not exist.", "error_details": "http://rcosnita.github.io/fantastico/html/features/roa/errors/error_10000.html"} ''' if version != "latest": version = float(version) params = CollectionParams(request, RoaController.OFFSET_DEFAULT, RoaController.LIMIT_DEFAULT) resource = self._resources_registry.find_by_url(resource_url, version) if not resource: return self._handle_resource_notfound(version, resource_url) self._inject_security_context(request, resource.model) access_token = self.validate_security_context(request, "read") json_serializer = self._json_serializer_cls(resource) filter_expr = self._parse_filter(params.filter_expr, resource.model) if resource.user_dependent: if filter_expr: filter_expr = ModelFilterAnd( filter_expr, ModelFilter(resource.model.user_id, access_token.user_id, ModelFilter.EQ)) else: filter_expr = ModelFilter(resource.model.user_id, access_token.user_id, ModelFilter.EQ) sort_expr = self._parse_sort(params.order_expr, resource.model) model_facade = self._model_facade_cls( resource.model, self._get_current_connection(request)) models = model_facade.get_records_paged(start_record=params.offset, end_record=params.offset + params.limit, filter_expr=filter_expr, sort_expr=sort_expr) items = [ json_serializer.serialize(model, params.fields) for model in models ] if resource.validator: resource.validator().format_collection(items, request) models_count = model_facade.count_records(filter_expr=filter_expr) body = {"items": items, "totalItems": models_count} response = Response(text=json.dumps(body), content_type="application/json", status_code=200) self._add_cors_headers(response) return response
def test_modelfilteror_wrongargtype(self): '''This test case ensures compound **or** filter works only with ModelFilter arguments.''' with self.assertRaises(FantasticoNotSupportedError): ModelFilterAnd(Mock(), Mock())
def test_modelfilterand_notenoughargs(self): '''This test case ensures compound **and** filter can not be built with a single argument.''' with self.assertRaises(FantasticoNotSupportedError): ModelFilterAnd(ModelFilter(self._model.id, 1, ModelFilter.EQ))
def test_modelfilterand_noargs(self): '''This test case ensures compound **and** filter can not be built without arguments.''' with self.assertRaises(FantasticoNotSupportedError): ModelFilterAnd()