def test_stack(self): with Context({}) as parent: context.field1 = 'parent value' with Context({}) as child: context.field1 = 'child value' self.assertEqual(context.field1, 'child value') self.assertIs(Context.get_current(), child) self.assertEqual(context.field1, 'parent value') self.assertIs(Context.get_current(), parent)
def test_ordering_mixin(db): session =db() for i in range(1, 6): obj = OrderingObject( title=f'object {6-i//2}', age=i * 10, ) session.add(obj) session.commit() query = session.query(OrderingObject) # Ascending with Context({'QUERY_STRING': 'sort=id'}): result = OrderingObject.sort_by_request(query).all() assert result[0].id == 1 assert result[-1].id == 5 # Descending with Context({'QUERY_STRING': 'sort=-id'}): result = OrderingObject.sort_by_request(query).all() assert result[0].id == 5 assert result[-1].id == 1 # Sort by Synonym Property with Context({'QUERY_STRING': 'sort=age'}): result = OrderingObject.sort_by_request(query).all() assert result[0].id == 1 assert result[-1].id == 5 # Mutiple sort criteria with Context({'QUERY_STRING': 'sort=title,id'}): result = OrderingObject.sort_by_request(query).all() assert result[0].id == 4 assert result[1].id == 5 assert result[2].id == 2 assert result[3].id == 3 assert result[4].id == 1 # Sort by date with Context({'QUERY_STRING': 'sort=-createdAt'}): result = OrderingObject.sort_by_request(query).all() assert result[0].id == 5 assert result[1].id == 4 assert result[2].id == 3 assert result[3].id == 2 assert result[4].id == 1
def test_session_member(self): with Context(environ={}, application=self.application): principal = self.application.__authenticator__.login( ('*****@*****.**', 'test')) self.assertEqual( self.application.__authenticator__.get_session_member( principal.session_id), 1)
def test_jsonpatch_querystring(): environ = {'REQUEST_METHOD': 'PATCH', 'QUERY_STRING': 'a=10'} with Context(environ): controller = SimpleJsonPatchController() context.form = [{ 'op': 'get', 'path': '/' }, { 'op': 'put', 'path': 'biscuits/1?a=1', 'value': { 'name': 'Ginger Nut' } }, { 'op': 'get', 'path': 'biscuits/2', 'value': { 'name': 'Ginger Nut' } }] result = ujson.loads(controller()) assert len(result) == 3 assert result[1]['a'] == '1' assert 'a' not in result[0] assert 'a' not in result[2]
def test_jsonpatch_rfc6902(self): environ = {'REQUEST_METHOD': 'PATCH'} with Context(environ): controller = SimpleJsonPatchController() context.form = [ { "op": "get", "path": "/" }, { "op": "put", "path": "biscuits/1", "value": { "name": "Ginger Nut" } }, { "op": "get", "path": "biscuits/2", "value": { "name": "Ginger Nut" } }, ] result = ujson.loads(controller()) self.assertEqual(len(result), 3)
def test_jsonpatch_caseinsesitive_verb(): environ = {'REQUEST_METHOD': 'PATCH', 'QUERY_STRING': 'a=10'} with Context(environ): controller = SimpleJsonPatchController() context.form = [ { 'op': 'GET', 'path': '/' }, { 'op': 'PUT', 'path': 'biscuits/1?a=1', 'value': { 'name': 'Ginger Nut' } }, { 'op': 'GET', 'path': 'biscuits/2', 'value': { 'name': 'Ginger Nut' } }, ] result = ujson.loads(controller()) assert len(result) == 3
def test_impersonation(): with Context({}) as ctx: role1 = 'role-1' role2 = 'role-2' role3 = 'role-3' role4 = 'role-4' # Simple test role_1_principal = DummyIdentity(role1) with ImpersonateAs(role_1_principal): assert context.identity == role_1_principal assert context.identity.is_in_roles(role1) # Now we change the role role_2_principal = DummyIdentity(role2) with ImpersonateAs(role_2_principal): assert not context.identity.is_in_roles(role1) assert context.identity.is_in_roles(role2) # Multiple roles role_3_4_principal = DummyIdentity(role3, role4) with ImpersonateAs(role_3_4_principal): assert context.identity.is_in_roles(role3) assert context.identity.is_in_roles(role4) assert not context.identity.is_in_roles(role1) assert not context.identity.is_in_roles(role2)
def test_authenticator(app): _ = app from nanohttp.contexts import Context with Context({}): authenticator = StatefulAuthenticator() member_id = 500 for session_id in ('bla_bla1', 'bla_bla2', 'bla_bla3'): authenticator.register_session(member_id=member_id, session_id=session_id) # Get session info info = authenticator.get_session_info(session_id=session_id) assert 'remoteAddress' in info last_sessions = sessions = authenticator.get_member_sessions(member_id) assert len(sessions) >= 0 authenticator.unregister_session(session_id) sessions = authenticator.get_member_sessions(member_id) assert len(sessions) == len(last_sessions) - 1 authenticator.invalidate_member(member_id) sessions = authenticator.get_member_sessions(member_id) assert len(sessions) == 0
def test_error(self): output_generator = self.error_action() with Context(environ={}) as context: self.assertEqual(next(output_generator), '11\r\nfirst chunk\r\n') self.assertEqual(next(output_generator), 'division by zero') self.assertEqual(next(output_generator), '0\r\n') self.assertEqual(next(output_generator), '\r\n')
def test_isonline(self): with Context(environ={}, application=self.__application__): authenticator = self.__application__.__authenticator__ principal = authenticator.login(('*****@*****.**', 'test')) assert authenticator.isonline(principal.session_id) == True authenticator.logout() assert authenticator.isonline(principal.session_id) == False
def test_trailer(self): output_generator = self.trailer_action() with Context(environ={}) as context: self.assertEqual(next(output_generator), '11\r\nfirst chunk\r\n') self.assertEqual(next(output_generator), '12\r\nsecond chunk\r\n') self.assertEqual(next(output_generator), '0\r\n') self.assertEqual(next(output_generator), 'field: value\r\n') self.assertEqual(next(output_generator), '\r\n') self.assertEqual(context.response_headers['trailer'], 'field')
def test_chunked(self): output_generator = self.chunked_action() with Context(environ={}) as context: self.assertEqual(next(output_generator), '11\r\nfirst chunk\r\n') self.assertEqual(next(output_generator), '12\r\nsecond chunk\r\n') self.assertEqual(next(output_generator), '11\r\nthird chunk\r\n') self.assertEqual(next(output_generator), '0\r\n') self.assertEqual(next(output_generator), '\r\n') self.assertEqual(context.response_headers['transfer-encoding'], 'chunked')
def test_pagination_mixin(self): for i in range(1, 6): # noinspection PyArgumentList obj = PagingObject( title='object %s' % i, ) DBSession.add(obj) DBSession.commit() with Context({'QUERY_STRING': 'take=2&skip=1'}, self.application) as context: self.assertEqual(PagingObject.paginate_by_request().count(), 2) self.assertEqual(context.response_headers['X-Pagination-Take'], '2') self.assertEqual(context.response_headers['X-Pagination-Skip'], '1') self.assertEqual(context.response_headers['X-Pagination-Count'], '5') with Context({'QUERY_STRING': 'take=two&skip=one'}, self.application): self.assertEqual(PagingObject.paginate_by_request().count(), 4) with Context({'QUERY_STRING': 'take=5'}, self.application): self.assertRaises(HttpBadRequest, PagingObject.paginate_by_request)
def test_model(db): session = db() __configuration__ = ''' timezone: ''' settings.merge(__configuration__) with Context({}): author1 = Author(title='author1', email='*****@*****.**', first_name='author 1 first name', last_name='author 1 last name', phone=None, password='******', birth=date(1, 1, 1), weight=1.1) post1 = Post(title='First post', author=author1, tag_time=time(1, 1, 1)) session.add(post1) session.commit() assert post1.id == 1 post1_dict = post1.to_dict() assert { 'author': { 'email': '*****@*****.**', 'firstName': 'author 1 first name', 'id': 1, 'lastName': 'author 1 last name', 'phone': None, 'title': 'author1', 'birth': '0001-01-01', 'weight': 1.100, 'age': 18 }, 'authorId': 1, 'comments': [], 'id': 1, 'tags': [], 'title': 'First post', 'tagTime': '01:01:01', }.items() < post1_dict.items() assert 'createdAt' in post1_dict assert 'modifiedAt' in post1_dict author1_dict = author1.to_dict() assert 'fullName' not in author1_dict
def test_pagination_mixin(db): session = db() for i in range(1, 6): obj = PagingObject(title='object %s' % i, ) session.add(obj) session.commit() query = session.query(PagingObject) with Context({'QUERY_STRING': 'take=2&skip=1'}) as context: assert PagingObject.paginate_by_request(query).count() == 2 assert context.response_headers['X-Pagination-Take'] == '2' assert context.response_headers['X-Pagination-Skip'] == '1' assert context.response_headers['X-Pagination-Count'] == '5' with Context({'QUERY_STRING': 'take=two&skip=one'}), \ pytest.raises(HTTPBadRequest): PagingObject.paginate_by_request(query).count() with Context({'QUERY_STRING': 'take=5'}), pytest.raises(HTTPBadRequest): PagingObject.paginate_by_request(query)
def test_ordering_mixin(self): for i in range(1, 6): # noinspection PyArgumentList obj = OrderableOrderingObject(title='object %s' % i, age=i * 10) DBSession.add(obj) # noinspection PyArgumentList obj = OrderingObject(title='object %s' % i, ) DBSession.add(obj) DBSession.commit() # Default soring with Orderable objects with Context({'QUERY_STRING': ''}, self.application): result = OrderableOrderingObject.sort_by_request().all() self.assertEqual(result[0].id, 1) self.assertEqual(result[-1].id, 5) # Default soring without Orderable objects with Context({'QUERY_STRING': ''}, self.application): result = OrderingObject.sort_by_request().all() self.assertEqual(len(result), 5) # Ascending with Context({'QUERY_STRING': 'sort=id'}, self.application): result = OrderableOrderingObject.sort_by_request().all() self.assertEqual(result[0].id, 1) self.assertEqual(result[-1].id, 5) # Descending with Context({'QUERY_STRING': 'sort=-id'}, self.application): result = OrderableOrderingObject.sort_by_request().all() self.assertEqual(result[0].id, 5) self.assertEqual(result[-1].id, 1) # Sort by Synonym Property with Context({'QUERY_STRING': 'sort=age'}, self.application): result = OrderableOrderingObject.sort_by_request().all() self.assertEqual(result[0].id, 1) self.assertEqual(result[-1].id, 5)
def test_jsonpatch_error(): environ = {'REQUEST_METHOD': 'PATCH'} with Context(environ), pytest.raises(Exception): controller = SimpleJsonPatchController() context.form = [{ 'op': 'put', 'path': 'biscuits/1', 'value': { 'name': 'Ginger Nut' } }, { 'op': 'error', 'path': 'biscuits', 'value': None }] controller()
def test_jsonpatch_error(self): environ = {'REQUEST_METHOD': 'PATCH'} with Context(environ): controller = SimpleJsonPatchController() context.form = [ { "op": "put", "path": "biscuits/1", "value": { "name": "Ginger Nut" } }, { "op": "error", "path": "biscuits", "value": None }, ] self.assertRaises(Exception, controller)
def test_jsonpatch_rfc6902(): environ = {'REQUEST_METHOD': 'PATCH'} with Context(environ): controller = SimpleJsonPatchController() context.form = [{ 'op': 'get', 'path': '/' }, { 'op': 'put', 'path': 'biscuits/1', 'value': { 'name': 'Ginger Nut' } }, { 'op': 'get', 'path': 'biscuits/2', 'value': { 'name': 'Ginger Nut' } }] result = ujson.loads(controller()) assert len(result) == 3
def __call__(self, environ, start_response): """Method that `WSGI <https://www.python.org/dev/peps/pep-0333/#id15>`_ server calls """ # Entering the context context_ = Context(environ, self) context_.__enter__() # Preparing some variables status = '200 OK' buffer = None response_iterable = None try: self._hook('begin_request') # Removing the trailing slash in-place, if exists context_.path = context_.path.rstrip('/') # Removing the heading slash, and query string anyway path = context_.path[1:].split('?')[0] # Splitting the path by slash(es) if any remaining_paths = path.split('/') if path else [] # Calling the controller, actually this will be serve our request response_body = self.__root__(*remaining_paths) if response_body: # The goal is to yield an iterable, to encode and iter over it # at the end of this method. if isinstance(response_body, (str, bytes)): # Mocking the body inside an iterable to prevent # the iteration over the str character by character # For more info check the pull-request # #34, https://github.com/Carrene/nanohttp/pull/34 response_iterable = (response_body, ) elif isinstance(response_body, types.GeneratorType): # Generators are iterable ! response_iterable = response_body # Trying to get at least one element from the generator, # to force the method call till the second # `yield` statement buffer = next(response_iterable) elif isinstance(response_body, Iterable): # Creating an iterator from iterable! response_iterable = iter(response_body) else: raise ValueError( 'Controller\'s action/handler response must be ' 'generator and or iterable') except Exception as ex: return self._handle_exception(ex, start_response) self._hook('begin_response') # Setting cookies in response headers, if any cookie = context_.cookies.output() if cookie: for line in cookie.split('\r\n'): context_.response_headers.add_header(*line.split(': ', 1)) start_response( status, context_.response_headers.items(), ) # It seems we have to transfer a body, so this function should yield # a generator of the body chunks. def _response(): try: if buffer is not None: yield context_.encode_response(buffer) if response_iterable: # noinspection PyTypeChecker for chunk in response_iterable: yield context_.encode_response(chunk) else: yield b'' except Exception as ex_: self.__logger__.exception( 'Exception while serving the response.') if settings.debug: yield str(ex_).encode() raise ex_ finally: self._hook('end_response') context.__exit__(*sys.exc_info()) return _response()
from nanohttp.contexts import Context from restfulpy.orm import DBSession, DeclarativeBase from sqlalchemy import func, select, and_ from sqlalchemy.orm import mapper from leo import leo from leo.models import Icd, Collection, collection_icd_table, Member leo.configure() leo.initialize_models() if __name__ == '__main__': with Context({}) as context: context.identity = vahid = Member.query.filter( Member.email == '*****@*****.**').one() # vahid.ensure_builtin_collections() # DBSession.commit() # # favorites = vahid.collections.filter(Collection.title == 'Favorites').one() # favorites.codes.append(Icd.query.filter(Icd.id == 1).one()) # DBSession.commit() collections_cte = select([ Collection.id.label('collection_id'), collection_icd_table.c.icd_id.label('icd_id') ]).select_from( Collection.__table__.join( collection_icd_table, collection_icd_table.c.collection_id == Collection.id)).where( Collection.user_id == context.identity.id).cte()
def test_filtering_mixin(db): session = db() for i in range(1, 6): session.add(FilteringObject( title='object %s' % i, )) session.add(FilteringObject( title='A simple title', )) session.commit() query = session.query(FilteringObject) with Context({'QUERY_STRING': 'id=1'}) as context, \ pytest.raises(HTTPBadRequest): context.query['id'] = 1 FilteringObject.filter_by_request(query) # IN with Context({'QUERY_STRING': 'id=IN(1,2,3)'}): assert FilteringObject.filter_by_request(query).count() == 3 # NOT IN with Context({'QUERY_STRING': 'id=!IN(1,2,3)'}): assert FilteringObject.filter_by_request(query).count() == 3 # IN (error) with Context({'QUERY_STRING': 'id=IN()'}), \ pytest.raises(HTTPBadRequest): FilteringObject.filter_by_request(query) # Between with Context({'QUERY_STRING': 'id=BETWEEN(1,3)'}): assert FilteringObject.filter_by_request(query).count() == 3 # IS NULL with Context({'QUERY_STRING': 'title=null'}): assert FilteringObject.filter_by_request(query).count() == 0 # IS NOT NULL with Context({'QUERY_STRING': 'title=!null'}): assert FilteringObject.filter_by_request(query).count() == 6 # == with Context({'QUERY_STRING': 'id=1'}): assert FilteringObject.filter_by_request(query).count() == 1 # != with Context({'QUERY_STRING': 'id=!1'}): assert FilteringObject.filter_by_request(query).count() == 5 # >= with Context({'QUERY_STRING': 'id=>=2'}): assert FilteringObject.filter_by_request(query).count() == 5 # > with Context({'QUERY_STRING': 'id=>2'}): assert FilteringObject.filter_by_request(query).count() == 4 # <= with Context({'QUERY_STRING': 'id=<=3'}): FilteringObject.filter_by_request(query).count() == 3 # < with Context({'QUERY_STRING': 'id=<3'}): assert FilteringObject.filter_by_request(query).count() == 2 # LIKE with Context({'QUERY_STRING': 'title=%obj%'}): assert FilteringObject.filter_by_request(query).count() == 5 with Context({'QUERY_STRING': 'title=%OBJ%'}): assert FilteringObject.filter_by_request(query).count() == 0 # ILIKE with Context({'QUERY_STRING': 'title=~%obj%'}): assert FilteringObject.filter_by_request(query).count() == 5 with Context({'QUERY_STRING': 'title=~%OBJ%'}): assert FilteringObject.filter_by_request(query).count() == 5 with Context({'QUERY_STRING': 'title=A sim%'}): assert FilteringObject.filter_by_request(query).count() == 1 with Context({'QUERY_STRING': 'title=%25ect 5'}): assert FilteringObject.filter_by_request(query).count() == 1 with Context({'QUERY_STRING': 'title=%imple%'}): assert FilteringObject.filter_by_request(query).count() == 1 with Context({'QUERY_STRING': 'title=~%IMPLE%'}): assert FilteringObject.filter_by_request(query).count() == 1
def test_filtering_mixin(self): for i in range(1, 6): # noinspection PyArgumentList obj = FilteringObject( title='object %s' % i, ) DBSession.add(obj) DBSession.commit() # Bad Value with Context({'QUERY_STRING': 'id=1'}, self.application) as context: context.query_string['id'] = 1 self.assertRaises(HttpBadRequest, FilteringObject.filter_by_request) # IN with Context({'QUERY_STRING': 'id=^1,2,3'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 3) # NOT IN with Context({'QUERY_STRING': 'id=!^1,2,3'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 2) # IN (error) with Context({'QUERY_STRING': 'id=^'}, self.application): self.assertRaises(HttpBadRequest, FilteringObject.filter_by_request) # Between with Context({'QUERY_STRING': 'id=~1,3'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 3) # IS NULL with Context({'QUERY_STRING': 'title=null'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 0) # IS NOT NULL with Context({'QUERY_STRING': 'title=!null'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 5) # LIKE with Context({'QUERY_STRING': 'title=%obj'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 5) with Context({'QUERY_STRING': 'title=%OBJ'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 0) # ILIKE with Context({'QUERY_STRING': 'title=%~obj'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 5) with Context({'QUERY_STRING': 'title=%~OBJ'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 5) # == with Context({'QUERY_STRING': 'id=1'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 1) # != with Context({'QUERY_STRING': 'id=!1'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 4) # >= with Context({'QUERY_STRING': 'id=>=2'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 4) # > with Context({'QUERY_STRING': 'id=>2'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 3) # <= with Context({'QUERY_STRING': 'id=<=3'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 3) # < with Context({'QUERY_STRING': 'id=<3'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 2)
def test_see_message(self): class Identity: def __init__(self, user): self.id = user.id self.reference_id = user.reference_id self.login(self.user1.email) with Context(dict()), cas_mockup_server(), self.given( f'See a message', f'/apiv1/messages/id:{self.message3.id}', f'SEE', query=dict(mimetype='!application/x-auditlog') ): assert status == 200 assert response.json['id'] == self.message3.id assert response.json['body'] == self.message3.body assert response.json['seenAt'] is not None assert response.json['attachment'] is not None assert response.json['modifiedAt'] is None assert response.json['seenBy'][0]['id'] is not None assert response.json['seenBy'][0]['referenceId'] is not None assert response.json['seenBy'][0]['title'] is not None assert response.json['seenBy'][0]['avatar'] is not None assert response.json['seenBy'][0]['email'] is not None assert response.json['seenBy'][0]['phone'] is None context.identity = Identity(self.user1) session = self.create_session() auditlog_message1 = session.query(Message) \ .get(self.auditlog_message1_id) auditlog_message2 = session.query(Message) \ .get(self.auditlog_message2_id) auditlog_message3 = session.query(Message) \ .get(self.auditlog_message3_id) assert auditlog_message1.seen_at is None assert auditlog_message2.seen_at is None assert auditlog_message3.seen_at is None message1 = session.query(Message).get(self.message1.id) message2 = session.query(Message).get(self.message2.id) message3 = session.query(Message).get(self.message3.id) assert message1.seen_at is not None assert message2.seen_at is not None assert message3.seen_at is not None when( 'See an auditlog message', url_parameters=dict(id=self.auditlog_message2_id), query=dict(mimetype='application/x-auditlog'), ) assert status == 200 session = self.create_session() auditlog_message1 = session.query(Message) \ .get(self.auditlog_message1_id) auditlog_message2 = session.query(Message) \ .get(self.auditlog_message2_id) auditlog_message3 = session.query(Message) \ .get(self.auditlog_message3_id) assert auditlog_message1.seen_at is not None assert auditlog_message2.seen_at is not None assert auditlog_message3.seen_at is None when( 'Sender wants to see own message', url_parameters=dict(id=self.message1.id) ) assert status == '621 Can Not See Own Message' when('Trying to pass with message already seen') assert status == '619 Message Already Seen' when('Message is not found', url_parameters=dict(id=0)) assert status == 404 when( 'Message is not found with alphabetical id', url_parameters=dict(id='Alphabetical') ) assert status == 404 when('Try to pass unauthorize request', authorization=None) assert status == 401
def __call__(self, environ, start_response): """Method that `WSGI <https://www.python.org/dev/peps/pep-0333/#id15>`_ server calls """ # Entering the context context_ = Context(environ, self) context_.__enter__() # Preparing some variables status = '200 OK' buffer = None response_iterable = None try: self._hook('begin_request') # Removing the trailing slash in-place, if exists context_.path = context_.path.rstrip('/') # Removing the heading slash, and query string anyway path = context_.path[1:].split('?')[0] # Splitting the path by slash(es) if any remaining_paths = path.split('/') if path else [] # Calling the controller, actually this will be serve our request response_body = self.__root__(*remaining_paths) if response_body: # The goal is to yield an iterable, to encode and iter over it # at the end of this method. if isinstance(response_body, types.GeneratorType): # Generators are iterable ! response_iterable = response_body # Trying to get at least one element from the generator, # to force the method call till the second # `yield` statement buffer = next(response_iterable) elif isinstance(response_body, (str, bytes)): # Mocking the body inside an iterable to prevent # the iteration over the str character by character # For more info check the pull-request # #34, https://github.com/Carrene/nanohttp/pull/34 response_iterable = (response_body, ) else: # Assuming the body is an iterable. response_iterable = response_body except Exception as ex: # the self._handle_exception may raise the error again, if the # error is not subclass of the HTTPStatusOtherwise, # a tuple of the status code and response body will be returned. status, response_body = self._handle_exception(ex) buffer = None response_iterable = (response_body, ) self._hook('begin_response') # Setting cookies in response headers, if any cookie = context_.cookies.output() if cookie: for line in cookie.split('\r\n'): context_.response_headers.add_header(*line.split(': ', 1)) # Sometimes don't need to transfer any body, for example the 304 case. if status[:3] in NO_CONTENT_STATUSES: del context_.response_headers['Content-Type'] start_response(status, context_.response_headers.items()) # This is only header, and body should not be transferred. # So the context is also should be destroyed context.__exit__(*sys.exc_info()) return [] else: start_response(status, context_.response_headers.items()) # It seems we have to transfer a body, so this function should yield # a generator of the body chunks. def _response(): try: if buffer is not None: yield context_.encode_response(buffer) if response_iterable: # noinspection PyTypeChecker for chunk in response_iterable: yield context_.encode_response(chunk) else: yield b'' except Exception as ex_: # pragma: no cover self.__logger__.exception( 'Exception while serving the response.') if settings.debug: yield str(ex_).encode() raise ex_ finally: self._hook('end_response') context.__exit__(*sys.exc_info()) return _response()
def test_model(self): with Context({}): # noinspection PyArgumentList author1 = Author(title='author1', email='*****@*****.**', first_name='author 1 first name', last_name='author 1 last name', phone=None, password='******', birth=date(1, 1, 1), weight=1.1) # noinspection PyArgumentList post1 = Post(title='First post', author=author1, tag_time=time(1, 1, 1)) DBSession.add(post1) DBSession.commit() self.assertEqual(post1.id, 1) # Validation, Type with self.assertRaises(HttpBadRequest): Author(title=234) # Validation, Pattern with self.assertRaises(HttpBadRequest): Author(email='invalidEmailAddress') # Validation, Min length with self.assertRaises(HttpBadRequest): Author(title='1') # Validation, Max length # Validation, Max length with self.assertRaises(HttpBadRequest): Author(phone='12321321321312321312312') # Metadata author_metadata = Author.json_metadata() self.assertIn('id', author_metadata['fields']) self.assertIn('email', author_metadata['fields']) self.assertEqual( author_metadata['fields']['fullName']['protected'], True) self.assertEqual( author_metadata['fields']['password']['protected'], True) post_metadata = Post.json_metadata() self.assertIn('author', post_metadata['fields']) comment_metadata = Comment.json_metadata() self.assertIn('post', comment_metadata['fields']) tag_metadata = Tag.json_metadata() self.assertIn('posts', tag_metadata['fields']) self.assertEqual( Comment.import_value(Comment.__table__.c.special, 'TRUE'), True) post1_dict = post1.to_dict() self.assertDictContainsSubset( { 'author': { 'email': '*****@*****.**', 'firstName': 'author 1 first name', 'id': 1, 'lastName': 'author 1 last name', 'phone': None, 'title': 'author1', 'birth': '0001-01-01', 'weight': '1.1000000000' }, 'authorId': 1, 'comments': [], 'id': 1, 'tags': [], 'title': 'First post', 'tagTime': '01:01:01' }, post1_dict, ) self.assertIn('createdAt', post1_dict) self.assertIn('modifiedAt', post1_dict) author1_dict = author1.to_dict() self.assertNotIn('fullName', author1_dict)
def test_filtering_mixin(self): for i in range(1, 6): # noinspection PyArgumentList DBSession.add(FilteringObject(title='object %s' % i, )) # noinspection PyArgumentList DBSession.add(FilteringObject(title='A simple title', )) DBSession.commit() # Bad Value with Context({'QUERY_STRING': 'id=1'}, self.application) as context: context.query_string['id'] = 1 self.assertRaises(HttpBadRequest, FilteringObject.filter_by_request) # IN with Context({'QUERY_STRING': 'id=IN(1,2,3)'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 3) # NOT IN with Context({'QUERY_STRING': 'id=!IN(1,2,3)'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 3) # IN (error) with Context({'QUERY_STRING': 'id=IN()'}, self.application): self.assertRaises(HttpBadRequest, FilteringObject.filter_by_request) # Between with Context({'QUERY_STRING': 'id=BETWEEN(1,3)'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 3) # IS NULL with Context({'QUERY_STRING': 'title=null'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 0) # IS NOT NULL with Context({'QUERY_STRING': 'title=!null'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 6) # == with Context({'QUERY_STRING': 'id=1'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 1) # != with Context({'QUERY_STRING': 'id=!1'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 5) # >= with Context({'QUERY_STRING': 'id=>=2'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 5) # > with Context({'QUERY_STRING': 'id=>2'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 4) # <= with Context({'QUERY_STRING': 'id=<=3'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 3) # < with Context({'QUERY_STRING': 'id=<3'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 2) # LIKE with Context({'QUERY_STRING': 'title=%obj%'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 5) with Context({'QUERY_STRING': 'title=%OBJ%'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 0) # ILIKE with Context({'QUERY_STRING': 'title=~%obj%'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 5) with Context({'QUERY_STRING': 'title=~%OBJ%'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 5) with Context({'QUERY_STRING': 'title=A sim%'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 1) with Context({'QUERY_STRING': 'title=%25ect 5'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 1) with Context({'QUERY_STRING': 'title=%imple%'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 1) with Context({'QUERY_STRING': 'title=~%IMPLE%'}, self.application): self.assertEqual(FilteringObject.filter_by_request().count(), 1)
def test_filtering_mixin(db): session = db() for i in range(1, 6): session.add(FilteringObject(title='object %s' % i, )) session.add(FilteringObject(title='A simple title', )) session.commit() query = session.query(FilteringObject) with Context({'QUERY_STRING': 'id=1'}) as context, \ pytest.raises(HTTPBadRequest): context.query['id'] = 1 FilteringObject.filter_by_request(query) # IN with Context({'QUERY_STRING': 'id=IN(1,2,3)'}): assert FilteringObject.filter_by_request(query).count() == 3 # NOT IN with Context({'QUERY_STRING': 'id=!IN(1,2,3)'}): assert FilteringObject.filter_by_request(query).count() == 3 # IN (error) with Context({'QUERY_STRING': 'id=IN()'}), \ pytest.raises(HTTPBadRequest): FilteringObject.filter_by_request(query) # Between with Context({'QUERY_STRING': 'id=BETWEEN(1,3)'}): assert FilteringObject.filter_by_request(query).count() == 3 # Not Between with Context({'QUERY_STRING': 'id=!BETWEEN(1,5)'}): assert FilteringObject.filter_by_request(query).count() == 1 # Bad Between with pytest.raises(HTTPBadRequest), \ Context({'QUERY_STRING': 'id=BETWEEN(1,)'}): FilteringObject.filter_by_request(query) # IS NULL with Context({'QUERY_STRING': 'title=%00'}): assert FilteringObject.filter_by_request(query).count() == 0 # IS NOT NULL with Context({'QUERY_STRING': 'title=!%00'}): assert FilteringObject.filter_by_request(query).count() == 6 # == with Context({'QUERY_STRING': 'id=1'}): assert FilteringObject.filter_by_request(query).count() == 1 # != with Context({'QUERY_STRING': 'id=!1'}): assert FilteringObject.filter_by_request(query).count() == 5 # >= with Context({'QUERY_STRING': 'id=>=2'}): assert FilteringObject.filter_by_request(query).count() == 5 # > with Context({'QUERY_STRING': 'id=>2'}): assert FilteringObject.filter_by_request(query).count() == 4 # <= with Context({'QUERY_STRING': 'id=<=3'}): FilteringObject.filter_by_request(query).count() == 3 # < with Context({'QUERY_STRING': 'id=<3'}): assert FilteringObject.filter_by_request(query).count() == 2 # LIKE with Context({'QUERY_STRING': 'title=%obj%'}): assert FilteringObject.filter_by_request(query).count() == 5 with Context({'QUERY_STRING': 'title=%OBJ%'}): assert FilteringObject.filter_by_request(query).count() == 0 # ILIKE with Context({'QUERY_STRING': 'title=~%obj%'}): assert FilteringObject.filter_by_request(query).count() == 5 with Context({'QUERY_STRING': 'title=~%OBJ%'}): assert FilteringObject.filter_by_request(query).count() == 5 with Context({'QUERY_STRING': 'title=A sim%'}): assert FilteringObject.filter_by_request(query).count() == 1 with Context({'QUERY_STRING': 'title=%25ect 5'}): assert FilteringObject.filter_by_request(query).count() == 1 with Context({'QUERY_STRING': 'title=%imple%'}): assert FilteringObject.filter_by_request(query).count() == 1 with Context({'QUERY_STRING': 'title=~%IMPLE%'}): assert FilteringObject.filter_by_request(query).count() == 1 session.add(Interval(start=1, end=4)) session.commit() query = session.query(Interval) # Filtering on hybrid property with Context({'QUERY_STRING': 'length=3'}): assert Interval.filter_by_request(query).count() == 1 # Get sure filtering on hybrid property works correctly with Context({'QUERY_STRING': 'length=2'}): assert Interval.filter_by_request(query).count() == 0
def test_session_member(self): with Context(environ={}, application=self.__application__): authenticator = self.__application__.__authenticator__ principal = authenticator.login(('*****@*****.**', 'test')) assert authenticator.get_member_id_by_session( principal.session_id) == 1
def test_content_length(self): with Context({'CONTENT_LENGTH': '', 'wsgi.input': io.BytesIO()}): form = context.form self.assertEqual({}, form)