def test_forward_no_method(self): controller = SampleActionController() controller.container = IocContainer() request = Request.from_environ(sample_environ()) context = {'request': request} controller.event = types.Event('test', params={'context': context}) controller.__action__ = 'do_method_forward' assert controller.do_method_forward() == 'Another Response'
def test_create_put_from_environ(self): data = 'HTTP_REQUEST_METHOD=PUT' environ = sample_environ(REQUEST_METHOD='POST', CONTENT_LENGTH=len(data)) environ['wsgi.input'] = BufferedReader(BytesIO(data.encode('utf-8'))) request = Request.from_environ(environ) assert request.post['HTTP_REQUEST_METHOD'] == 'PUT' assert not request.files assert request.is_method('PUT')
def setup(self): self.protected_form = has_csrf(UnprotectedForm) data = 'test=blah' environ = sample_environ(REQUEST_METHOD='POST') environ['wsgi.input'] = BufferedReader(BytesIO(data.encode('utf-8'))) environ['CONTENT_LENGTH'] = len(data) self.request = Request.from_environ( environ, 'watson.http.sessions.Memory')
def create_event(self, **kwargs): router = DictRouter({"home": {"path": "/"}}) environ = {} util.setup_testing_defaults(environ) environ.update(**kwargs) context = {"request": Request.from_environ(environ)} event = Event("TestEvent", params={"router": router, "context": context}) return event
def test_last_exception(self): # occurs when exceptions have been raised from others environ = sample_environ() context = {'request': Request.from_environ(environ)} app = applications.Http() response, view_model = app.exception(last_exception=True, exception=Exception('test'), context=context) assert '<h1>Internal Server Error</h1>' in response.body
def test_flash_message(self): controller = SampleActionController() controller.request = Request('GET') controller.flash_messages.add('testing') controller.flash_messages.add('something') assert controller.flash_messages['info'] == ['testing', 'something'] for namespace, message in controller.flash_messages: assert namespace == 'info' assert not controller.flash_messages.messages
def test_flash_message(self): controller = SampleActionController() controller.request = Request.from_environ(sample_environ(), "watson.http.sessions.Memory") controller.flash_messages.add("testing") controller.flash_messages.add("something") assert controller.flash_messages["info"] == ["testing", "something"] for namespace, message in controller.flash_messages: assert namespace == "info" assert not controller.flash_messages.messages
def test_flash_message(self): controller = SampleActionController() controller.request = Request.from_environ(sample_environ(), 'watson.http.sessions.Memory') controller.flash_messages.add('testing') controller.flash_messages.add('something') assert controller.flash_messages['info'] == ['testing', 'something'] for namespace, message in controller.flash_messages: assert namespace == 'info' assert not controller.flash_messages.messages
def test_invalid_user(self): post_data = 'username=simon&password=test' environ = sample_environ(REQUEST_METHOD='POST', CONTENT_LENGTH=len(post_data)) environ['wsgi.input'] = BufferedReader( BytesIO(post_data.encode('utf-8'))) self.controller.request = Request.from_environ(environ, 'watson.http.sessions.Memory') response = self.controller.login_action() assert response.headers['location'] == '/login'
def test_invalid_form(self): post_data = 'username=simon' environ = sample_environ(REQUEST_METHOD='POST', CONTENT_LENGTH=len(post_data)) environ['wsgi.input'] = BufferedReader( BytesIO(post_data.encode('utf-8'))) self.controller.request = Request.from_environ(environ, 'watson.http.sessions.Memory') self.controller.login_action() assert len(self.controller.flash_messages) == 1
def test_last_exception(self): # occurs when exceptions have been raised from others environ = sample_environ() context = { 'request': Request.from_environ(environ) } app = applications.Http() response, view_model = app.exception( last_exception=True, exception=Exception('test'), context=context) assert '<h1>Internal Server Error</h1>' in response.body
def setup(self): data = 'form_csrf_token=123456&test=blah' environ = sample_environ( HTTP_COOKIE='watson.session=123456;', REQUEST_METHOD='POST', CONTENT_LENGTH=len(data)) environ['wsgi.input'] = BufferedReader( BytesIO(data.encode('utf-8'))) self.request = Request.from_environ( environ, 'watson.http.sessions.Memory')
def test_session_from_https_request(self): environ = sample_environ(HTTPS='HTTPS') request = Request.from_environ(environ, session_class='watson.http.sessions.Memory') assert request.is_secure() request.session['arbitrary'] = 'value' sessions.session_to_cookie(request, Response()) cookie = request.cookies[sessions.COOKIE_KEY] assert cookie['httponly'] assert cookie['secure']
def setup(self): post_data = 'username=admin&password=test' environ = sample_environ(REQUEST_METHOD='POST', CONTENT_LENGTH=len(post_data)) environ['wsgi.input'] = BufferedReader( BytesIO(post_data.encode('utf-8'))) self.controller = support.app.container.get( 'tests.watson.auth.test_decorators.SampleController') self.controller.request = Request.from_environ(environ, 'watson.http.sessions.Memory') self.controller.login_action()
def test_create(self): data = 'test' environ = sample_environ(CONTENT_LENGTH=len(data)) environ['wsgi.input'] = BufferedReader(BytesIO(data.encode('utf-8'))) request = Request.from_environ(environ) assert request.method == 'GET' assert not request.is_method('PUT', 'PATCH') assert repr(request) == '<watson.http.messages.Request method:GET url:http://127.0.0.1/>' assert 'Content-Length: 4' in str(request) assert "\r\n\r\ntest" in str(request)
def setup(self): controller = support.app.container.get( 'tests.watson.auth.test_decorators.SampleController') event = types.Event('test', params={ 'context': { 'request': Request.from_environ(sample_environ(), 'watson.http.sessions.Memory') } }) controller.event = event self.controller = controller
def test_json_body(self): json_str = '{"test": [1, 2, 3]}' environ = sample_environ(CONTENT_TYPE='application/json; charset=utf-8', CONTENT_LENGTH=len(json_str), REQUEST_METHOD='put') environ['wsgi.input'] = BufferedReader( BytesIO(json_str.encode('utf-8'))) request = Request.from_environ(environ) json_output = json.loads(request.body) assert 'test' in json_output assert 'test' in request.json_body
def create_event(self, **kwargs): router = DictRouter({'home': {'path': '/'}}) environ = {} util.setup_testing_defaults(environ) environ.update(**kwargs) context = {'request': Request.from_environ(environ)} event = Event( 'TestEvent', params={'router': router, 'context': context}) return event
def test_short_circuit(self): environ = sample_environ() route = LiteralRoute( "test", path="/", options={"controller": "tests.watson.framework.support.ShortCircuitedController"} ) match = RouteMatch(route, {}) context = {"request": Request.from_environ(environ), "route_match": match} event = Event("something", params={"container": IocContainer(), "context": context}) listener = listeners.DispatchExecute({"404": "page/404"}) response, view_model = listener(event) assert isinstance(response, Response)
def test_multiple_values(self): form = MultipleForm('test') data = 'checkbox[]=1&checkbox[]=2' environ = sample_environ( REQUEST_METHOD='POST', CONTENT_LENGTH=len(data)) environ['wsgi.input'] = BufferedReader( BytesIO(data.encode('utf-8'))) request = Request.from_environ( environ, 'watson.http.sessions.Memory') form.data = request assert form.test == ['1', '2']
def test_overriden_template(self): environ = sample_environ() route = LiteralRoute( "test", path="/", options={"controller": "tests.watson.framework.support.SampleActionController"} ) match = RouteMatch(route, {"action": "view_model_template"}) context = {"request": Request.from_environ(environ), "route_match": match} event = Event("something", params={"container": IocContainer(), "context": context}) listener = listeners.DispatchExecute({"404": "page/500"}) response, view_model = listener(event) assert isinstance(view_model, views.Model) assert view_model.template == "sampleactioncontroller/404"
def run(self, environ, start_response): session = self.config['session'] request = Request.from_environ(environ, session_class=session.get( 'class', None), session_options=session.get( 'options', None)) try: response = self.__run_inner(request) except Exception as exc: response, view_model = self.exception( exception=exc, context={'request': request}) return response(start_response)
def test_short_circuit(self): environ = sample_environ() route = LiteralRoute( 'test', path='/', options={'controller': 'tests.watson.framework.support.ShortCircuitedController'}) match = RouteMatch(route, {}) context = {'request': Request.from_environ(environ), 'route_match': match} event = Event( 'something', params={'container': IocContainer(), 'context': context}) listener = listeners.DispatchExecute({'404': 'page/404'}) response, view_model = listener(event) assert isinstance(response, Response)
def test_set_data_on_form(self): form = LoginForm('test') post_data = { 'username': '******', 'password': '******', 'first_name': None, 'last_name': None, 'email': None} form.data = post_data assert form.data == post_data environ = environ_with_file() request = Request.from_environ(environ) form.data = request assert form.data['first_name'] == '1234'
def routes(self, path, method, format, server): """Aids in the debugging of routes associated. Args: path: Validate the specified path against the router method: The http request method format: The http request format server: The hostname of the request """ try: router = self.router if not router.routes: raise ConsoleError( 'There are no routes associated with the application.') if path: environ = {} util.setup_testing_defaults(environ) server = server or '127.0.0.1' environ.update({ 'REQUEST_METHOD': method or 'GET', 'HTTP_ACCEPT': format or 'text/html', 'PATH_INFO': path, 'SERVER_NAME': server, 'HTTP_HOST': server }) request = Request.from_environ(environ) matches = [match for match in router.matches(request)] if matches: longest_route = max([match.route.name for match in matches], key=len) self.write( colors.header('Displaying {} matching routes for {}:\n'.format( len(matches), request.url))) for match in matches: route = match.route self.write('{0}\t{1}\n'.format( route.name.rjust(len(longest_route)), route.path)) else: raise ConsoleError('There are no matching routes.') else: self.write(colors.header('Displaying {0} routes for the application:\n'.format(len(router)))) longest_route = max(router, key=len) for name, route in router: self.write('{0}\t{1}\n'.format( name.rjust(len(longest_route[0])), route.path)) except ConsoleError: raise except Exception as e: raise e _no_application_error()
def test_post_redirect_get(self): base = controllers.HttpMixin() router = DictRouter({"test": {"path": "/test"}}) environ = sample_environ(PATH_INFO="/", REQUEST_METHOD="POST") environ["wsgi.input"] = BufferedReader(BytesIO(b"post_var_one=test&post_var_two=blah")) base.request = Request.from_environ(environ, "watson.http.sessions.Memory") base.container = Mock() base.container.get.return_value = router response = base.redirect("test") assert response.status_code == 303 assert base.redirect_vars == base.request.session["post_redirect_get"] base.clear_redirect_vars() assert not base.redirect_vars base.redirect("test", clear=True) assert not base.redirect_vars
def test_overriden_template(self): environ = sample_environ() route = LiteralRoute( 'test', path='/', options={'controller': 'tests.watson.framework.support.SampleActionController'}) match = RouteMatch(route, {'action': 'view_model_template'}) context = {'request': Request.from_environ(environ), 'route_match': match} event = Event( 'something', params={'container': IocContainer(), 'context': context}) listener = listeners.DispatchExecute({'404': 'page/500'}) response, view_model = listener(event) assert isinstance(view_model, views.Model) assert view_model.template == 'sampleactioncontroller/404'
def run(self, environ, start_response): request = Request.from_environ( environ, session_class=self.config['session'].get('class', None), session_options=self.config['session'].get('options', None)) context = {'request': request} self.context = context # Retrieve the required route match for the request. try: route_result = self.dispatcher.trigger( Event(events.ROUTE_MATCH, target=self, params={ 'context': context, 'router': self.container.get('router') })) route_match = route_result.first() except ApplicationError as exc: route_match = None response, view_model = self.exception(exception=exc, context=context) # Execute the relevant controller for the route if route_match: try: dispatch_result = self.dispatcher.trigger( Event(events.DISPATCH_EXECUTE, target=self, params={ 'container': self.container, 'context': context })) response, view_model = dispatch_result.first() except ApplicationError as exc: response, view_model = self.exception(exception=exc, context=context) # Render the view model or response if not hasattr(view_model, 'status_code'): try: self.render(context=context, view_model=view_model) except Exception as exc: response, view_model = self.exception(exception=exc, context=context) # Do any cleanup required after the request has ended self.dispatcher.trigger( Event(events.COMPLETE, target=self, params={'container': self.container})) return response(start_response)
def test_redirect(self): base = controllers.HttpMixin() router = DictRouter( { "test": {"path": "/test"}, "segment": {"path": "/segment[/:part]", "type": "segment", "defaults": {"part": "test"}}, } ) base.request = Request.from_environ(sample_environ()) base.container = Mock() base.container.get.return_value = router response = base.redirect("/test") assert response.headers["location"] == "/test" response = base.redirect("segment") assert response.headers["location"] == "/segment/test" assert response.status_code == 302
def test_set_data_on_form(self): form = LoginForm('test') post_data = { 'username': '******', 'password': '******', 'first_name': None, 'last_name': None, 'email': None } form.data = post_data assert form.data == post_data request = Request('GET', post={'first_name': 'data'}, files={'file': 'something'}) form.data = request assert form.data['first_name'] == 'data'
def run(self, environ, start_response): request = Request.from_environ(environ, session_class=self.config['session'].get('class', None), session_options=self.config['session'].get('options', None)) context = { 'request': request } self.context = context # Retrieve the required route match for the request. try: route_result = self.dispatcher.trigger( Event( events.ROUTE_MATCH, target=self, params={'context': context, 'router': self.container.get('router')})) route_match = route_result.first() except self.exception_class as exc: route_match = None response, view_model = self.exception(exception=exc, context=context) # Execute the relevant controller for the route if route_match: try: dispatch_result = self.dispatcher.trigger( Event( events.DISPATCH_EXECUTE, target=self, params={'container': self.container, 'context': context})) response, view_model = dispatch_result.first() except self.exception_class as exc: response, view_model = self.exception( exception=exc, context=context) # Render the view model or response if not hasattr(view_model, 'status_code'): try: self.render(context=context, view_model=view_model) except Exception as exc: response, view_model = self.exception(exception=exc, context=context) # Do any cleanup required after the request has ended self.dispatcher.trigger(Event(events.COMPLETE, target=self, params={'container': self.container})) return response(start_response)
def test_post_redirect_get(self): base = controllers.HttpMixin() router = DictRouter({'test': {'path': '/test'}}) environ = sample_environ(PATH_INFO='/', REQUEST_METHOD='POST') environ['wsgi.input'] = BufferedReader( BytesIO(b'post_var_one=test&post_var_two=blah')) base.request = Request.from_environ( environ, 'watson.http.sessions.Memory') base.container = Mock() base.container.get.return_value = router response = base.redirect('test') assert response.status_code == 303 assert base.redirect_vars == base.request.session['post_redirect_get'] base.clear_redirect_vars() assert not base.redirect_vars base.redirect('test', clear=True) assert not base.redirect_vars
def test_post_redirect_get(self): base = controllers.HttpMixin() router = DictRouter({'test': {'path': '/test'}}) environ = sample_environ(PATH_INFO='/', REQUEST_METHOD='POST') environ['wsgi.input'] = BufferedReader( BytesIO(b'post_var_one=test&post_var_two=blah')) base.request = Request.from_environ(environ, 'watson.http.sessions.Memory') base.container = Mock() base.container.get.return_value = router response = base.redirect('test') assert response.status_code == 303 assert base.redirect_vars == base.request.session['post_redirect_get'] base.clear_redirect_vars() assert not base.redirect_vars base.redirect('test', clear=True) assert not base.redirect_vars
def execute(self): try: router = self.container.get('router') if not router.routes: raise ConsoleError( 'There are no routes associated with the application.') if self.parsed_args.url: environ = {} util.setup_testing_defaults(environ) environ.update({ 'REQUEST_METHOD': self.parsed_args.method or 'GET', 'HTTP_ACCEPT': self.parsed_args.format or 'text/html', 'PATH_INFO': self.parsed_args.url, 'SERVER_NAME': self.parsed_args.server or '127.0.0.1' }) request = Request.from_environ(environ) matches = router.matches(request) if matches: sys.stdout.write( colors.header( 'Displaying {0} matching routes for the application:\n' .format(len(matches)))) for match in matches: sys.stdout.write('{0}\t\t\{1}\t\t{2}\n'.format( colors.ok_green(match.route.name), match.route.path, match.route.regex.pattern)) else: raise ConsoleError('There are no matching routes.') else: sys.stdout.write( colors.header( 'Displaying {0} routes for the application:\n'.format( len(router)))) for name, route in router: sys.stdout.write('{0}\t\t{1}\n'.format(name, route.path)) except ConsoleError: raise except: _no_application_error()
def test_redirect(self): base = controllers.HttpMixin() router = DictRouter({ 'test': { 'path': '/test', }, 'segment': { 'path': '/segment[/:part]', 'type': 'segment', 'defaults': {'part': 'test'} } }) base.request = Request.from_environ(sample_environ()) base.container = Mock() base.container.get.return_value = router response = base.redirect('/test') assert response.headers['location'] == '/test' response = base.redirect('segment') assert response.headers['location'] == '/segment/test' assert response.status_code == 302
def execute(self): try: router = self.container.get('router') if not router.routes: raise ConsoleError( 'There are no routes associated with the application.') if self.parsed_args.url: environ = {} util.setup_testing_defaults(environ) environ.update({ 'REQUEST_METHOD': self.parsed_args.method or 'GET', 'HTTP_ACCEPT': self.parsed_args.format or 'text/html', 'PATH_INFO': self.parsed_args.url, 'SERVER_NAME': self.parsed_args.server or '127.0.0.1' }) request = Request.from_environ(environ) matches = router.matches(request) if matches: sys.stdout.write( colors.header('Displaying {0} matching routes for the application:\n'.format(len(matches)))) for match in matches: sys.stdout.write( '{0}\t\t\{1}\t\t{2}\n'.format( colors.ok_green( match.route.name), match.route.path, match.route.regex.pattern)) else: raise ConsoleError('There are no matching routes.') else: sys.stdout.write( colors.header('Displaying {0} routes for the application:\n'.format(len(router)))) for name, route in router: sys.stdout.write('{0}\t\t{1}\n'.format(name, route.path)) except ConsoleError: raise except: _no_application_error()
def test_execute_result(self): controller = SampleRestController() controller.request = Request('GET') result = controller.execute(something='test') assert result == 'GET'
def test_request_response(self): base = controllers.HttpMixin() base.request = Request('GET') assert isinstance(base.request, Request) assert isinstance(base.response, Response)
def setup(self): controller = support.app.container.get( 'tests.watson.auth.test_decorators.SampleController') controller.request = Request.from_environ(sample_environ(), 'watson.http.sessions.Memory') self.controller = controller
def test_method_template(self): controller = SampleRestController() controller.request = Request('GET') assert controller.get_execute_method_path() == [ 'samplerestcontroller', 'get']
def test_no_session(self): controller = SampleActionController() controller.request = Request.from_environ({}) with raises(Exception): controller.flash_messages
def test_create_invalid_headers(self): request = Request('get', headers={'Something': 'test'}) assert request.headers.__len__() == 1
def test_execute_result(self): controller = SampleRestController() controller.request = Request.from_environ(sample_environ()) result = controller.execute(something='test') assert result == 'GET'
def test_method_template(self): controller = SampleRestController() controller.request = Request.from_environ(sample_environ()) assert controller.get_execute_method_path() == [ 'samplerestcontroller', 'get' ]
def test_request_response(self): base = controllers.HttpMixin() base.request = Request.from_environ(sample_environ()) assert isinstance(base.request, Request) assert isinstance(base.response, Response)
def test_create(self): request = Request('get') assert request.method == 'GET'
def test_forward(self): controller = SampleActionController() request = Request.from_environ(sample_environ()) context = {'request': request} controller.event = types.Event('test', params={'context': context}) assert controller.do_forward() == 'Response'
def test_create_invalid(self): Request('INVALID')
def test_blank_response(self): controller = SampleActionController() controller.request = Request.from_environ(sample_environ()) result = controller.execute(action='blank') assert isinstance(result, dict)