def test_child_route_creation(self): router = Router({ 'home': { 'path': '/' }, 'parent': { 'path': '/parent', 'children': { 'child_one': { 'path': '/child_one', 'children': { 'sub_child': { 'path': '/test' } } }, 'child_two': { 'path': '/child_two' } } } }) assert len(router) == 5 request = create_request_from_environ(sample_environ(PATH_INFO='/child_one')) matches = router.matches(request) assert len(matches) == 0 request = create_request_from_environ(sample_environ(PATH_INFO='/parent/child_one')) matches = router.matches(request) assert len(matches) == 1 assert router.assemble('parent/child_one/sub_child') == '/parent/child_one/test'
def test_static_match(self): route = Route(name='home', path='/') invalid_request = create_request_from_environ( sample_environ(PATH_INFO='/test')) valid_request = create_request_from_environ( sample_environ(PATH_INFO='/')) assert not route.match(invalid_request) assert route.match(valid_request)
def test_accept_method_match(self): valid_request = create_request_from_environ( sample_environ(PATH_INFO='/test', REQUEST_METHOD='POST')) invalid_request = create_request_from_environ( sample_environ(PATH_INFO='/test', REQUEST_METHOD='GET')) route = Route(name='test', path='/test', accepts=('POST',)) assert route.match(valid_request) assert not route.match(invalid_request)
def test_mandatory_segment_match(self): route = Route("search", path='/search/:keyword') invalid_request = create_request_from_environ( sample_environ(PATH_INFO='/searching')) valid_request_no_param = create_request_from_environ( sample_environ(PATH_INFO='/search')) valid_request_with_param = create_request_from_environ( sample_environ(PATH_INFO='/search/test')) assert not route.match(invalid_request) assert not route.match(valid_request_no_param) assert route.match(valid_request_with_param)
def test_optional_segment_with_required(self): route = Route( name="search", path='/search[/:keyword]', requires={'keyword': 'blah'}) valid_request = create_request_from_environ( sample_environ(PATH_INFO='/search/blah')) invalid_request = create_request_from_environ( sample_environ(PATH_INFO='/search/test')) assert not route.match(invalid_request) assert route.match(valid_request)
def test_optional_segment_match(self): route = Route(name="search", path='/search[/:keyword]') invalid_request = create_request_from_environ( sample_environ(PATH_INFO='/searching')) valid_request = create_request_from_environ( sample_environ(PATH_INFO='/search')) valid_request_with_param = create_request_from_environ( sample_environ(PATH_INFO='/search/test')) assert not route.match(invalid_request) assert route.match(valid_request) assert route.match(valid_request_with_param)
def test_requires_get_variables(self): route = Route(name='test', path='/', requires={'test': '.*'}) request = create_request_from_environ(sample_environ( PATH_INFO='/', QUERY_STRING='test=blah&something=test')) match = route.match(request) assert match request = create_request_from_environ(sample_environ( PATH_INFO='/', QUERY_STRING='tesst=blah')) match = route.match(request) assert not match
def test_subdomain_match(self): valid_request = create_request_from_environ( sample_environ(PATH_INFO='/test', SERVER_NAME='clients.test.com', HTTP_HOST='clients.test.com')) invalid_request = create_request_from_environ( sample_environ(PATH_INFO='/test', SERVER_NAME='clients2.test.com', HTTP_HOST='clients2.test.com')) route = Route(name='test', path='/test', subdomain='clients') assert route.match(valid_request) assert not route.match(invalid_request) route_multiple_subdomains = Route(name='test', path='/test', subdomain=('clients', 'test')) assert route_multiple_subdomains.match(valid_request) assert not route_multiple_subdomains.match(invalid_request)
def test_call(self): application = applications.Http({ 'routes': { 'home': { 'path': '/', 'options': { 'controller': 'tests.watson.framework.support.TestController' }, 'requires': { 'format': 'json' } } }, 'views': { 'templates': { 'watson/mvc/test_applications/testcontroller/post': 'blank' } }, 'debug': { 'enabled': True } }) environ = sample_environ(PATH_INFO='/', REQUEST_METHOD='POST', HTTP_ACCEPT='application/json') response = application(environ, start_response) assert response == [b'{"content": "Posted Hello World!"}']
def test_format_match(self): valid_request = create_request_from_environ( sample_environ(PATH_INFO='/dump', HTTP_ACCEPT='application/json')) invalid_request = create_request_from_environ( sample_environ(PATH_INFO='/dump', HTTP_ACCEPT='application/xml')) valid_request_segment = create_request_from_environ( sample_environ(PATH_INFO='/dump.json')) route = Route(name='json', path='/dump', requires={'format': 'json'}) route_format = Route( name='json', path='/dump.:format', requires={'format': 'json'}) assert route.match(valid_request) assert not route.match(invalid_request) assert route_format.match(valid_request_segment)
def test_optional_segment_with_defaults(self): route = Route( name="search", path='/search[/:keyword]', defaults={'keyword': 'blah'}) invalid_request = create_request_from_environ( sample_environ(PATH_INFO='/searching')) valid_request = create_request_from_environ( sample_environ(PATH_INFO='/search')) valid_request_with_param = create_request_from_environ( sample_environ(PATH_INFO='/search/test')) valid_request_with_default = route.match(valid_request) assert not route.match(invalid_request) assert valid_request_with_default assert valid_request_with_default.params == {'keyword': 'blah'} assert route.match(valid_request_with_param)
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_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_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.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_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_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 setup(self): app = applications.Http() p = Request( {'enabled': True}, app.container.get('jinja2_renderer'), app) self.app = app self.panel = p params = { 'context': { 'request': messages.Request.from_environ(support.sample_environ()) } } p.event = types.Event('test', params=params)
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 test_raise_exception_event_server_error(self): application = applications.Http({ 'routes': { 'home': { 'path': '/', 'options': { 'controller': 'tests.watson.framework.support.TestController' } } } }) response = application(sample_environ(PATH_INFO='/'), start_response) assert '<h1>Internal Server Error</h1>' in response[0].decode('utf-8')
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_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 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_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 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_sort_routes(self): router = Router({ 'home': { 'path': '/' }, 'test': { 'path': '/' }, 'highest': { 'path': '/', 'priority': 1000 }, 'lowest': { 'path': '/', 'priority': -1 } }) request = create_request_from_environ(sample_environ(PATH_INFO='/')) matches = router.matches(request) assert matches[0].route.name == 'highest' assert matches[3].route.name == 'lowest'
def test_application_logic_error(self): application = applications.Http({ 'routes': { 'home': { 'path': '/', 'options': { 'controller': 'tests.watson.framework.support.SampleActionController', 'action': 'blah_syntax_error' } } }, 'views': { 'templates': { 'watson/mvc/test_applications/testcontroller/blah_syntax_error': 'blank' } } }) response = application(sample_environ(PATH_INFO='/'), start_response) assert '<h1>Internal Server Error</h1>' in response[0].decode('utf-8')
def test_json_output(self): application = applications.Http({ 'routes': { 'home': { 'path': '/', 'options': { 'controller': 'tests.watson.framework.support.AnotherSampleActionController', }, 'defaults': { 'action': 'json' }, } }, 'debug': { 'enabled': True } }) environ = sample_environ(PATH_INFO='/', REQUEST_METHOD='GET', HTTP_ACCEPT='application/json') response = application(environ, start_response) assert response == [b'{"name": "value"}']
def test_blank_response(self): controller = SampleActionController() controller.request = Request.from_environ(sample_environ()) result = controller.execute(action='blank') assert isinstance(result, dict)
def test_raise_exception_event_not_found(self): application = applications.Http() response = application(sample_environ(PATH_INFO='/'), start_response) assert '<h1>Not Found</h1>' in response[0].decode('utf-8')
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_run(self): response = self.panel.run(support.sample_environ(), support.start_response) assert isinstance(response[0], bytes)
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_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_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' ]