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 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 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_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 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 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_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 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)
