def boot(self, router: Route, request: Request, response: Response):
# All routes joined
for route in self.app.make('WebRoutes'):
"""Make a better match for trailing slashes
Sometimes a user will end with a trailing slash. Because the user might
create routes like `/url/route` and `/url/route/` and how the regex
is compiled down, we may need to adjust for urls that end or dont
end with a trailing slash.
"""
matchurl = create_matchurl(router, route)
"""Houston, we've got a match
Check to see if a route matches the corresponding router url. If a match
is found, execute that route and break out of the loop. We only need
one match. Routes are executed on a first come, first serve basis
"""
if matchurl.match(router.url) and request.get_request_method() in route.method_type:
route.load_request(request)
"""Check if subdomains are active and if the route matches on the subdomain
It needs to match to.
"""
if request.has_subdomain():
# Check if the subdomain matches the correct routes domain
if not route.has_required_domain():
response.view('Route not found. Error 404')
continue
"""Get URL Parameters
This will create a dictionary of parameters given. This is sort of a short
but complex way to retrieve the url parameters.
This is the code used to convert /url/@firstname/@lastname
to {'firstmane': 'joseph', 'lastname': 'mancuso'}.
"""
try:
parameter_dict = {}
for index, value in enumerate(matchurl.match(router.url).groups()):
parameter_dict[router.generated_url_list()[index]] = value
request.set_params(parameter_dict)
except AttributeError:
pass
"""Excute HTTP before middleware
Only those middleware that have a "before" method are ran.
"""
for http_middleware in self.app.make('HttpMiddleware'):
located_middleware = self.app.resolve(
http_middleware
)
if hasattr(located_middleware, 'before'):
located_middleware.before()
"""Execute Route Before Middleware
This is middleware that contains a before method.
"""
route.run_middleware('before')
# Show a helper in the terminal of which route has been visited
if application.DEBUG:
print(request.get_request_method() + ' Route: ' + router.url)
# If no routes have been found and no middleware has changed the status code
if request.is_status(404):
"""Get the response from the route and set it on the 'Response' key.
This data is typically the output of the controller method depending
on the type of route.
"""
response.view(route.get_response(), status=200)
"""Execute Route After Route Middleware
This is middleware that contains an after method.
"""
route.run_middleware('after')
"""Excute HTTP after middleware
Only those middleware that have an "after" method are ran.
Check here if the middleware even has the required method.
"""
for http_middleware in self.app.make('HttpMiddleware'):
located_middleware = self.app.resolve(http_middleware)
if hasattr(located_middleware, 'after'):
located_middleware.after()
"""Return breaks the loop because the incoming route is found and executed.
There is no need to continue searching the route list. First come
first serve around these parts of the woods.
"""
return
"""No Response was found in the for loop so let's set an arbitrary response now.
"""
response.view('Route not found. Error 404', status=404)
# If the route exists but not the method is incorrect
if request.is_status(404) and request.route_exists(request.path):
response.view('Method not allowed', status=405)
class TestRequest:
def setup_method(self):
self.app = App()
self.request = Request(wsgi_request).key(
'NCTpkICMlTXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=').load_app(self.app)
self.app.bind('Request', self.request)
self.response = Response(self.app)
self.app.simple(Response)
def test_request_is_callable(self):
""" Request should be callable """
if callable(self.request):
assert True
def test_request_input_should_return_input_on_get_request(self):
assert self.request.input('application') == 'Masonite'
assert self.request.input('application', 'foo') == 'Masonite'
def test_request_input_should_return_default_when_not_exists(self):
assert self.request.input('foo', 'bar') == 'bar'
def test_request_all_should_return_params(self):
assert self.request.all() == {'application': 'Masonite'}
def test_request_all_without_internal_request_variables(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
assert self.request.all() == {
'__token': 'testing',
'application': 'Masonite'
}
assert self.request.all(internal_variables=False) == {
'application': 'Masonite'
}
def test_request_has_should_return_bool(self):
assert self.request.has('application') == True
assert self.request.has('shouldreturnfalse') == False
def test_request_has_should_accept_multiple_values(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
assert self.request.has('application') == True
assert self.request.has('shouldreturnfalse') == False
assert self.request.has('__token') == True
assert self.request.has('__token', 'shouldreturnfalse') == False
assert self.request.has('__token', 'application') == True
assert self.request.has('__token', 'application',
'shouldreturnfalse') == False
def test_request_set_params_should_return_self(self):
assert self.request.set_params({'value': 'new'}) == self.request
assert self.request.url_params == {'value': 'new'}
def test_request_param_returns_parameter_set_or_false(self):
self.request.set_params({'value': 'new'})
assert self.request.param('value') == 'new'
assert self.request.param('nullvalue') == False
def test_request_appends_cookie(self):
assert self.request.cookie('appendcookie', 'value') == self.request
assert 'appendcookie' in self.request.environ['HTTP_COOKIE']
def test_request_sets_and_gets_cookies(self):
self.request.cookie('setcookie', 'value')
assert self.request.get_cookie('setcookie') == 'value'
def test_request_sets_expiration_cookie_2_months(self):
self.request.cookies = []
self.request.cookie('setcookie_expiration',
'value',
expires='2 months')
time = cookie_expire_time('2 months')
assert self.request.get_cookie('setcookie_expiration') == 'value'
assert 'Expires={0}'.format(time) in self.request.cookies[0][1]
def test_delete_cookie(self):
self.request.cookies = []
self.request.cookie('delete_cookie', 'value')
assert self.request.get_cookie('delete_cookie') == 'value'
self.request.delete_cookie('delete_cookie')
assert not self.request.get_cookie('delete_cookie')
def test_delete_cookie_with_wrong_key(self):
self.request.cookies = []
self.request.cookie('cookie', 'value')
self.request.key('wrongkey_TXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=')
assert self.request.get_cookie('cookie') is None
def test_redirect_returns_request(self):
assert self.request.redirect('newurl') == self.request
assert self.request.redirect_url == '/newurl'
def test_request_no_input_returns_false(self):
assert self.request.input('notavailable') == False
def test_request_mini_field_storage_returns_single_value(self):
storages = {'test': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
assert self.request.input('test') == '1'
def test_request_can_get_string_value(self):
storages = {'test': 'value'}
self.request._set_standardized_request_variables(storages)
assert self.request.input('test') == 'value'
def test_request_mini_field_storage_doesnt_return_brackets(self):
storages = {'test[]': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
assert self.request.input('test') == '1'
def test_request_mini_field_storage_index(self):
storages = {'test[index]': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
assert self.request.input('test[index]') == '1'
def test_request_mini_field_storage_with_dot_notation(self):
storages = {'test[index]': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
assert self.request.input('test.index') == '1'
def test_request_mini_field_storage_returns_a_list(self):
storages = {
'test':
[MiniFieldStorage('key', '1'),
MiniFieldStorage('key', '2')]
}
self.request._set_standardized_request_variables(storages)
assert self.request.input('test') == ['1', '2']
def test_request_get_cookies_returns_cookies(self):
assert self.request.get_cookies() == self.request.cookies
def test_request_set_user_sets_object(self):
assert self.request.set_user(object) == self.request
assert self.request.user_model == object
assert self.request.user() == object
def test_request_loads_app(self):
app = App()
app.bind('Request', self.request)
app.make('Request').load_app(app)
assert self.request.app() == app
assert app.make('Request').app() == app
def test_request_gets_input_from_container(self):
container = App()
container.bind('Application', application)
container.bind('Providers', providers)
container.bind('WSGI', object)
container.bind('Environ', wsgi_request)
for provider in container.make('Providers').PROVIDERS:
provider().load_app(container).register()
container.bind('Response', 'test')
container.bind('WebRoutes', [
Get().route('url', None),
Get().route('url/', None),
Get().route('url/@firstname', None),
])
container.bind('Response', 'Route not found. Error 404')
for provider in container.make('Providers').PROVIDERS:
located_provider = provider().load_app(container)
container.resolve(located_provider.boot)
assert container.make('Request').input('application') == 'Masonite'
assert container.make('Request').all() == {'application': 'Masonite'}
container.make('Request').environ['REQUEST_METHOD'] = 'POST'
assert container.make('Request').environ['REQUEST_METHOD'] == 'POST'
assert container.make('Request').input('application') == 'Masonite'
def test_redirections_reset(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', WEB_ROUTES)
request = app.make('Request').load_app(app)
request.redirect('test')
assert request.redirect_url == '/test'
request.reset_redirections()
assert request.redirect_url is False
request.redirect_to('test')
assert request.redirect_url == '/test'
request.reset_redirections()
assert request.redirect_url is False
def test_request_has_subdomain_returns_bool(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
assert request.has_subdomain() is False
assert request.subdomain is None
request.environ['HTTP_HOST'] = 'test.localhost.com'
request.header('TEST', 'set_this')
assert request.header('TEST') == 'set_this'
request.header('TEST', 'set_this', http_prefix=True)
assert request.header('HTTP_TEST') == 'set_this'
def test_redirect_compiles_url(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = '/test/url'
assert request.compile_route_to_url(route) == '/test/url'
def test_redirect_compiles_url_with_1_slash(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = '/'
assert request.compile_route_to_url(route) == '/'
def test_request_route_returns_url(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
get('/test/url', None).name('test.url'),
get('/test/url/@id', None).name('test.id')
])
request = app.make('Request').load_app(app)
assert request.route('test.url') == '/test/url'
assert request.route('test.id', {'id': 1}) == '/test/url/1'
def test_request_redirection(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
get('/test/url', 'TestController@show').name('test.url'),
get('/test/url/@id', 'TestController@testing').name('test.id'),
get('/test/url/object', TestController.show).name('test.object')
])
request = app.make('Request').load_app(app)
assert request.redirect('/test/url/@id', {
'id': 1
}).redirect_url == '/test/url/1'
request.redirect_url = None
assert request.redirect(name='test.url').redirect_url == '/test/url'
request.redirect_url = None
assert request.redirect(name='test.id', params={
'id': 1
}).redirect_url == '/test/url/1'
request.redirect_url = None
assert request.redirect(
controller='TestController@show').redirect_url == '/test/url'
request.redirect_url = None
assert request.redirect(
controller=TestController.show).redirect_url == '/test/url/object'
request.redirect_url = None
assert request.redirect('some/url').redirect_url == '/some/url'
def test_request_route_returns_full_url(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
get('/test/url', None).name('test.url'),
get('/test/url/@id', None).name('test.id')
])
request = app.make('Request').load_app(app)
assert request.route('test.url',
full=True) == 'http://localhost/test/url'
def test_redirect_compiles_url_with_multiple_slashes(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/url/here'
assert request.compile_route_to_url(route) == '/test/url/here'
def test_redirect_compiles_url_with_trailing_slash(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/url/here/'
assert request.compile_route_to_url(route) == '/test/url/here/'
def test_redirect_compiles_url_with_parameters(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id'
params = {
'id': '1',
}
assert request.compile_route_to_url(route, params) == '/test/1'
def test_redirect_compiles_url_with_multiple_parameters(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id/@test'
params = {
'id': '1',
'test': 'user',
}
assert request.compile_route_to_url(route, params) == '/test/1/user'
def test_request_compiles_custom_route_compiler(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id:signed'
params = {
'id': '1',
}
assert request.compile_route_to_url(route, params) == '/test/1'
def test_redirect_compiles_url_with_http(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = "http://google.com"
assert request.compile_route_to_url(route) == 'http://google.com'
def test_request_gets_correct_header(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
assert request.header('HTTP_UPGRADE_INSECURE_REQUESTS') == '1'
assert request.header('RAW_URI') == '/'
assert request.header('NOT_IN') == ''
assert not 'text/html' in request.header('NOT_IN')
def test_request_sets_correct_header(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.header('TEST', 'set_this')
assert request.header('TEST') == 'set_this'
request.header('TEST', 'set_this', http_prefix=True)
assert request.header('HTTP_TEST') == 'set_this'
def test_request_cant_set_multiple_headers(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.header('TEST', 'test_this')
request.header('TEST', 'test_that')
assert request.header('TEST') == 'test_that'
def test_request_sets_headers_with_dictionary(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.header({
'test_dict': 'test_value',
'test_dict1': 'test_value1'
})
assert request.header('test_dict') == 'test_value'
assert request.header('test_dict1') == 'test_value1'
request.header({
'test_dict': 'test_value',
'test_dict1': 'test_value1'
},
http_prefix=True)
assert request.header('HTTP_test_dict') == 'test_value'
assert request.header('HTTP_test_dict1') == 'test_value1'
def test_request_gets_all_headers(self):
app = App()
app.bind('Request', Request(wsgi_request))
request = app.make('Request').load_app(app)
request.header('TEST1', 'set_this_item')
assert request.get_headers() == [('TEST1', 'set_this_item')]
def test_request_sets_str_status_code(self):
app = App()
app.bind('Request', self.request)
app.bind('StatusCode', '404 Not Found')
request = app.make('Request').load_app(app)
request.status('200 OK')
assert request.get_status_code() == '200 OK'
def test_request_sets_int_status_code(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(500)
assert request.get_status_code() == '500 Internal Server Error'
def test_request_gets_int_status(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(500)
assert request.get_status() == 500
def test_can_get_code_by_value(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(500)
assert request._get_status_code_by_value(
'500 Internal Server Error') == 500
def test_is_status_code(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(500)
assert request.is_status(500) == True
def test_request_sets_invalid_int_status_code(self):
with pytest.raises(InvalidHTTPStatusCode):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(600)
def test_request_sets_request_method(self):
wsgi = generate_wsgi()
wsgi['QUERY_STRING'] = '__method=PUT'
request = Request(wsgi)
assert request.has('__method')
assert request.input('__method') == 'PUT'
assert request.get_request_method() == 'PUT'
def test_request_has_should_pop_variables_from_input(self):
self.request.request_variables.update({'key1': 'test', 'key2': 'test'})
self.request.pop('key1', 'key2')
assert self.request.request_variables == {'application': 'Masonite'}
self.request.pop('shouldnotexist')
assert self.request.request_variables == {'application': 'Masonite'}
self.request.pop('application')
assert self.request.request_variables == {}
def test_is_named_route(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
get('/test/url', None).name('test.url'),
get('/test/url/@id', None).name('test.id')
])
request = app.make('Request').load_app(app)
request.path = '/test/url'
assert request.is_named_route('test.url')
request.path = '/test/url/1'
assert request.is_named_route('test.id', {'id': 1})
def test_route_exists(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
get('/test/url', None).name('test.url'),
get('/test/url/@id', None).name('test.id')
])
request = app.make('Request').load_app(app)
assert request.route_exists('/test/url') == True
assert request.route_exists('/test/Not') == False
def test_request_url_from_controller(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
get('/test/url', 'TestController@show').name('test.url'),
get('/test/url/@id', 'ControllerTest@show').name('test.id'),
get('/test/url/controller/@id',
TestController.show).name('test.controller'),
])
request = app.make('Request').load_app(app)
assert request.url_from_controller(
'TestController@show') == '/test/url'
assert request.url_from_controller('ControllerTest@show',
{'id': 1}) == '/test/url/1'
assert request.url_from_controller(
TestController.show, {'id': 1}) == '/test/url/controller/1'
def test_contains_for_path_detection(self):
self.request.path = '/test/path'
assert self.request.contains('/test/*')
assert self.request.contains('/test/path')
assert not self.request.contains('/test/wrong')
def test_contains_for_path_with_digit(self):
self.request.path = '/test/path/1'
assert self.request.contains('/test/path/*')
assert self.request.contains('/test/path/*:int')
def test_contains_for_path_with_digit_and_wrong_contains(self):
self.request.path = '/test/path/joe'
assert not self.request.contains('/test/path/*:int')
def test_contains_for_path_with_alpha_contains(self):
self.request.path = '/test/path/joe'
assert self.request.contains('/test/path/*:string')
def test_contains_for_route_compilers(self):
self.request.path = '/test/path/joe'
assert self.request.contains('/test/path/*:signed')
def test_contains_multiple_asteriks(self):
self.request.path = '/dashboard/user/edit/1'
assert self.request.contains('/dashboard/user/*:string/*:int')
def test_back_returns_correct_url(self):
self.request.path = '/dashboard/create'
self.request.back()
assert self.request.redirect_url == '/dashboard/create'
self.request.back(default='/home')
assert self.request.redirect_url == '/home'
self.request.request_variables = {'__back': '/login'}
self.request.back(default='/home')
assert self.request.redirect_url == '/login'
def test_request_without(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
assert self.request.without('__token') == {'application': 'Masonite'}
def test_request_only_returns_specified_values(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
assert self.request.only('application') == {'application': 'Masonite'}
assert self.request.only('__token') == {'__token': 'testing'}
'HTTP_UPGRADE_INSECURE_REQUESTS': '1',
'HTTP_COOKIE': 'setcookie=value',
'HTTP_USER_AGENT': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/604.4.7 (KHTML, like Gecko) Version/11.0.2 Safari/604.4.7',
'HTTP_ACCEPT_LANGUAGE': 'en-us',
'HTTP_ACCEPT_ENCODING': 'gzip, deflate',
'HTTP_CONNECTION': 'keep-alive',
'wsgi.url_scheme': 'http',
'REMOTE_ADDR': '127.0.0.1',
'REMOTE_PORT': '62241',
'SERVER_NAME': '127.0.0.1',
'SERVER_PORT': '8000',
'PATH_INFO': '/',
'SCRIPT_NAME': ''
}
REQUEST = Request(wsgi_request)
def test_validator():
pass
# validator = Validator()
# assert validator.validate() == validator
def test_validator_sets_request():
validator = Validator(REQUEST)
assert validator.request is REQUEST
def test_email_validator_sets_dictionary():
def setUp(self):
self.route = Route(generate_wsgi())
self.request = Request(generate_wsgi())
def edit(self, view: View, request: Request):
post = Post.find(request.param('id'))
return view.render('edit', {'post': post})
def setUp(self):
self.request = Request(generate_wsgi()).key(
'NCTpkICMlTXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=')
self.request.activate_subdomains()
from masonite.app import App
from masonite.request import Request
from masonite.testsuite.TestSuite import generate_wsgi
import unittest
REQUEST = Request({}).load_environ(generate_wsgi())
class MockMail:
def __init__(self, request: Request):
self.request = request
class TestApp(unittest.TestCase):
def setUp(self):
self.app = App()
def test_app_binds(self):
self.app.bind('test1', object)
self.app.bind('test2', object)
self.assertEqual(self.app.providers, {
'test1': object,
'test2': object
})
def test_app_makes(self):
self.app.bind('Request', REQUEST)
self.assertEqual(self.app.make('Request').cookies, [])
def test_app_makes_and_resolves(self):
self.app.bind('Request', REQUEST)
def challenge(self, request: Request):
challenge = request.input('challenge')
return challenge
def show_user(self, request: Request):
return request.param("id")
class TestCSRFMiddleware:
def setup_method(self):
self.app = App()
wsgi = generate_wsgi()
self.request = Request(wsgi)
self.route = Route().load_environ(wsgi)
self.view = View(self.app)
self.app.bind('Request', self.request)
self.request = self.app.make('Request')
self.app.bind('WebRoutes', [
Get().route('/test/@route', None),
Get().route('/test/10', None),
])
self.request.container = self.app
self.middleware = CsrfMiddleware(self.request, Csrf(self.request),
self.view)
def test_middleware_shares_correct_input(self):
self.middleware.before()
assert 'csrf_field' in self.view._shared
assert self.view._shared['csrf_field'].startswith(
"<input type='hidden' name='__token' value='")
def test_middleware_throws_exception_on_post(self):
self.request.environ['REQUEST_METHOD'] = 'POST'
self.request.path = '/'
self.middleware.exempt = []
with pytest.raises(InvalidCSRFToken):
self.middleware.before()
def test_middleware_can_accept_param_route(self):
self.request.environ['REQUEST_METHOD'] = 'POST'
self.request.path = '/test/1'
self.middleware.exempt = ['/test/@route']
self.middleware.before()
def test_middleware_can_exempt(self):
self.request.environ['REQUEST_METHOD'] = 'POST'
self.request.path = '/test/1'
self.middleware.exempt = ['/test/1']
self.middleware.before()
def test_middleware_throws_exeption_on_wrong_route(self):
self.request.environ['REQUEST_METHOD'] = 'POST'
self.request.path = '/test/10'
self.middleware.exempt = ['/test/2']
with pytest.raises(InvalidCSRFToken):
self.middleware.before()
def test_incoming_token_does_not_throw_exception_with_token(self):
self.request.environ['REQUEST_METHOD'] = 'POST'
self.request.request_variables.update(
{'__token': self.request.get_cookie('csrf_token')})
self.middleware.exempt = []
self.middleware.before()
def test_generates_csrf_token(self):
assert len(self.middleware.generate_token()) == 30
def test_generates_token_every_request(self):
token1 = self.middleware.verify_token()
token2 = self.middleware.verify_token()
assert len(token1) == 30
assert len(token2) == 30
assert token1 != token2
def test_does_not_generate_token_every_request(self):
self.middleware.every_request = False
token1 = self.middleware.verify_token()
token2 = self.middleware.verify_token()
assert len(token1) == 30
assert len(token2) == 30
assert token1 == token2
from masonite.app import App
from masonite.request import Request
from masonite.routes import Get, Post
from masonite.exceptions import ContainerError
import inspect
import pytest
REQUEST = Request({})
class TestApp:
def setup_method(self):
self.app = App()
def test_app_binds(self):
self.app.bind('test1', object)
self.app.bind('test2', object)
assert self.app.providers == {'test1': object, 'test2': object}
def test_app_makes(self):
self.app.bind('Request', REQUEST)
assert self.app.make('Request').cookies == []
def test_throws_exception_if_too_many_bindings(self):
REQUEST.cookies = ['hey']
self.app.bind('Request', REQUEST)
self.app.bind('Route', Get().route('test/', None))
with pytest.raises(ContainerError, message="should raise error"):
self.app.resolve(self._functest)
def _functest(Request, get: Get, post: Post):
def upload(self, upload: Upload, view: View, request: Request):
filename = upload.driver('disk').store(request.input('image_upload'))
return view.render('welcome', {'image_url': f'/uploads/{filename}'})
def update(self, request: Request):
"""Logic to update data from a given model
"""
record = self.model.find(request.param('id'))
record.update(request.all())
return record
def show(self, request: Request):
"""Logic to read data from 1 model
"""
return self.model.find(request.param('id'))
def show(self, view: View, request: Request):
if not Auth(request).user():
request.redirect('/login')
return view.render('home', {'app': app, 'Auth': Auth(request)})
def register(self, request: Request, auth: Auth, validate: Validator,
mail: Mail):
""" register a new customer and also checks that form is filled out properly without errors and checks to see if email, passwords, and
usernames alread exits"""
email = User.lists('email')
user_name = User.lists('username')
pws = User.lists('password')
errors = request.validate(
validate.required([
'firstname', 'lastname', 'address', 'email', 'username',
'password', 'cell_phone'
]),
validate.email('email'),
validate.strong(
'password',
length=8,
special=1,
uppercase=1,
# breach=True checks if the password has been breached before.
# Requires 'pip install pwnedapi'
breach=False))
#Will display what errors where committed when filling out registration form.
if errors:
return request.back().with_errors(errors).with_input()
#check to see if emails or usernames already exist
accounts = [email, user_name]
inputs = [request.input('email'), request.input('username')]
for input in inputs:
for account in accounts:
if inputs[0] in accounts[0] and inputs[1] in accounts[1]:
return request.back().with_errors({
'error': [
'{} and {} already exists'.format(
inputs[0], inputs[1])
]
})
elif input in account:
return request.back().with_errors(
{'error': ['{} already exists'.format(input)]})
# checking to see if password already exists
for pw in pws:
if bcrypt.checkpw(bytes(request.input('password'), 'utf-8'),
bytes(pw, 'utf-8')):
return request.back().with_errors({
'error': [
'Password already exists. Please create a new password.'
]
})
if request.input('password') != request.input('password_confirm'):
return request.back().with_errors({
'error':
['Passwords do not match. Please make sure passwords match']
})
#This registers a new account
user = auth.register({
'firstname': request.input('firstname'),
'lastname': request.input('lastname'),
'address': request.input('address'),
'cell_phone': request.input('cell_phone'),
'email': request.input('email'),
'username': request.input('username'),
'password': request.input('password')
})
#Checking to see if all inputs on registration form are in correct format.
#Will send an email confirming account has been created.
mail.send_from(
'*****@*****.**').subject('Account Confirmation').to(
request.input('email')).template('mail/mail').send()
# Login the user
if auth.login(request.input('email'), request.input('password')):
# Redirect to the homepage
return request.redirect('/')
return request.back().with_input()
class TestRequestRoutes(unittest.TestCase):
def setUp(self):
self.request = Request(generate_wsgi()).key(
'NCTpkICMlTXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=')
self.request.activate_subdomains()
def test_get_initialized(self):
self.assertTrue(callable(Get))
self.assertTrue(callable(Post))
def test_get_sets_route(self):
self.assertTrue(Get().route('test', None))
def test_sets_name(self):
get = Get().route('test', None).name('test')
self.assertEqual(get.named_route, 'test')
def test_loads_request(self):
get = Get().route('test', None).name('test').load_request('test')
self.assertEqual(get.request, 'test')
def test_loads_middleware(self):
get = Get().route('test', None).middleware('auth', 'middleware')
self.assertEqual(get.list_middleware, ['auth', 'middleware'])
def test_method_type(self):
self.assertEqual(Post().method_type, ['POST'])
self.assertEqual(Get().method_type, ['GET'])
def test_method_type_sets_domain(self):
get = Get().domain('test')
post = Post().domain('test')
self.assertEqual(get.required_domain, 'test')
self.assertEqual(post.required_domain, 'test')
def test_method_type_has_required_subdomain(self):
get = Get().domain('test')
post = Get().domain('test')
self.request.environ['HTTP_HOST'] = 'test.localhost:8000'
get.request = post.request = self.request
self.assertEqual(get.has_required_domain(), True)
self.assertEqual(post.has_required_domain(), True)
def test_method_type_has_required_subdomain_with_asterick(self):
container = TestSuite().create_container()
request = container.container.make('Request')
request.environ['HTTP_HOST'] = 'test.localhost:8000'
request.activate_subdomains()
get = Get().domain('*')
post = Get().domain('*')
get.request = request
post.request = request
self.assertEqual(get.has_required_domain(), True)
self.assertEqual(post.has_required_domain(), True)
def test_request_sets_subdomain_on_get(self):
container = TestSuite().create_container()
request = container.container.make('Request')
request.environ['HTTP_HOST'] = 'test.localhost:8000'
request.activate_subdomains()
get = Get().domain('*')
post = Get().domain('*')
get.request = request
post.request = request
get.has_required_domain()
self.assertEqual(request.param('subdomain'), 'test')
def test_route_changes_module_location(self):
get = Get().module('app.test')
self.assertEqual(get.module_location, 'app.test')
def setup_method(self):
self.route = Route(generate_wsgi())
self.request = Request(generate_wsgi())
def forget(self, view: View, request: Request, auth: Auth):
return view.render("auth/forget", {
"app": request.app().make("Application"),
"Auth": auth
})
def _schema(self, request: Request):
model_name = request.param('model')
table_name = inflection.tableize(model_name)
row = self.get_model_row_by_model_name(model_name)
#model_i = row['model']()
#table = model_i.get_table()
if env('DB_CONNECTION') == 'sqlite':
# Get Schema in SQLite with Python
# https://www.tomordonez.com/get-schema-sqlite-python.html
db = sqlite3.connect(env('DB_DATABASE'))
cursor = db.cursor()
cursor.execute(f"PRAGMA table_info('{table_name}')")
schema = list(cursor.fetchall())
for i, row in enumerate(schema):
row = list(row)
schema[i] = {'id': row[0], 'column': row[1], 'type': row[2]}
cursor.execute(f"PRAGMA foreign_key_list('{table_name}')")
foreign_list = cursor.fetchall()
elif env('DB_CONNECTION') == 'mysql':
conn = pymysql.connect(host=env('DB_HOST'),
user=env('DB_USERNAME'),
password=env('DB_PASSWORD'),
db=env('DB_DATABASE'),
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
with conn.cursor() as cursor:
sql = f'SELECT * FROM {table_name} LIMIT 1'
cursor.execute(sql)
schema = cursor.description
schema = list(schema)
for i, row in enumerate(schema):
new_row = {'id': i, 'column': row[0], 'type': row[1]}
for k, v in MYSQL_FIELD_TYPE.items():
if str(new_row['type']) == k:
new_row['type'] = v
schema[i] = new_row
foreign_list = []
with conn.cursor() as cursor:
sql = f'SHOW CREATE TABLE {table_name}'
cursor.execute(sql)
filedata = cursor.fetchone()['Create Table']
filedata_arr = filedata.splitlines()
for data in filedata_arr:
row_in_foreign_list = [0, 0, 'table', 'key']
if 'FOREIGN KEY' in data:
row = data.split('`')
row_in_foreign_list[3] = row[3]
row_in_foreign_list[2] = row[5]
foreign_list += [row_in_foreign_list]
elif env('DB_CONNECTION') == 'postgres':
conn = psycopg2.connect(host=env('DB_HOST'),
database=env('DB_DATABASE'),
user=env('DB_USERNAME'),
password=env('DB_PASSWORD'),
port=env('DB_PORT'))
with conn.cursor() as cursor:
sql = f"select column_name, data_type from information_schema.columns where table_name = '{table_name}'"
cursor.execute(sql)
schema = cursor.fetchall()
for i, row in enumerate(schema):
new_row = {
'id': i,
'column': row[0],
'type': row[1].split(' ')[0]
}
for k, v in PGSQL_FIELD_TYPE.items():
if str(new_row['type']) == k:
new_row['type'] = v
schema[i] = new_row
break
foreign_list = []
with conn.cursor() as cursor:
sql = "SELECT table_name, constraint_name FROM information_schema.table_constraints WHERE table_schema = 'public' AND constraint_type = 'FOREIGN KEY'"
cursor.execute(sql)
filedata = cursor.fetchall()
for i, v in enumerate(filedata):
key_name = v[1]
key_name = key_name.replace(f'{table_name}_', '')
key_name = key_name.strip('_foreign')
if v[0] == table_name:
foreign_list += [
(i, 0, inflection.pluralize(key_name.strip('_id')),
key_name)
]
foreign = {}
for row in foreign_list:
data = self.foreign_data(self, row[2]) # row[2] = table_name
foreign[row[3]] = data # row[3] = column_name
return {'schema': schema, 'foreign_keys': foreign}
def logout(self, request: Request, auth: Auth):
auth.logout()
request.session.flash('success',
'We will see you next time, Whooooooooo!!!!!!')
return request.redirect('/')
def register(self, request: Request, auth: Auth, validate: Validator):
""" register a new administrator and also checks that form is filled out properly without errors and checks to see if email, passwords, and
usernames alread exits"""
email = Administrator.lists('admin_email')
user_name = Administrator.lists('admin_username')
pw = Administrator.lists('password')
#check to see if emails or usernames already exist
accounts = [email, user_name]
inputs = [request.input('admin_email'), request.input('admin_username')]
for input in inputs:
for account in accounts:
if inputs[0] in accounts[0] and inputs[1] in accounts[1]:
return request.back().with_errors({'error': ['{} and {} already exists'.format(inputs[0], inputs[1])]})
elif input in account:
return request.back().with_errors({'error': ['{} already exists'.format(input)]})
#checking to see if password already exists
for pw in pw:
if bcrypt.checkpw(bytes(request.input('admin_password'), 'utf-8'), bytes(pw, 'utf-8')):
return request.back().with_errors({'error': ['Password already exists. Please create a new password.']})
#checking for user entry errors when registering as an Administrator
errors = request.validate(
validate.required(['admin_name', 'admin_cell_phone', 'admin_address', 'admin_email', 'admin_username', 'admin_password']),
validate.email('admin_email'),
validate.strong('admin_password', length=8, special=1, uppercase=1)
)
if errors:
return request.back().with_errors(errors).with_input()
#when everything above checks out ok, then go ahead and insert data in Administrator table
else:
encoded_jwt = jwt.encode({'email': request.input('admin_email')},os.getenv('KEY') ,algorithm='HS256')
encrypted_password = password(request.input('admin_password'))
Administrator.insert(admin_name=request.input('admin_name'),
admin_cell_phone=request.input('admin_cell_phone'),
admin_address=request.input('admin_address'),
admin_email=request.input('admin_email'),
admin_username=request.input('admin_username'),
password=encrypted_password,
remember_token=encoded_jwt)
return request.redirect('/admin')
def single(self, view: View, request: Request):
post = Post.find(request.param('id'))
return view.render('single', {'post': post})
def show(self, view: View, request: Request):
if request.user():
return request.redirect('/')
return view.render('login')
def delete(self, request: Request):
post = Post.find(request.param('id'))
post.delete()
return 'post deleted'
def store(self, request: Request, auth: Auth, validate: Validator,
view: View):
user = User.all()
email = User.lists('email')
pw = User.lists('password')
errors = request.validate(validate.required(['email', 'password']),
validate.email('email'))
#checks for errors in login inputs and redirects user back to login page.
if errors:
return request.back().with_errors(errors).with_input()
elif request.input('email') not in email and request.input(
'password') not in pw:
return request.back().with_errors(
{'email': ["Email and password not found. Please register."]})
#check to see if user already had an account which they may have closed/cancelled and need to register for a new account or reactivate account.
if user.where('email',
request.input('email')).where('cancelled', 'Yes'):
# cancelled = True
user_id = User.where('email',
request.input('email')).get().pluck('id')
return request.redirect('/reregister/' + str(user_id[0]))
#logins user if no errors and account has not been closed/cancelled before
if auth.login(request.input('email'), request.input('password')):
return request.redirect('/')
# returns back to login page if email or password are incorrect
return request.back().with_errors(
{'email': ["Email or password is incorrect"]})
def change_header(self, request: Request):
request.header('Content-Type', 'application/xml')
return 'test'
class TestRequest(unittest.TestCase):
def setUp(self):
self.app = App()
self.request = Request(wsgi_request).key(
'NCTpkICMlTXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=').load_app(self.app)
self.app.bind('Request', self.request)
self.response = Response(self.app)
self.app.simple(Response)
def test_request_is_callable(self):
""" Request should be callable """
self.assertIsInstance(self.request, object)
def test_request_input_should_return_input_on_get_request(self):
self.assertEqual(self.request.input('application'), 'Masonite')
self.assertEqual(self.request.input('application', 'foo'), 'Masonite')
def test_request_input_should_return_default_when_not_exists(self):
self.assertEqual(self.request.input('foo', 'bar'), 'bar')
def test_request_all_should_return_params(self):
self.assertEqual(self.request.all(), {'application': 'Masonite'})
def test_request_all_without_internal_request_variables(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
self.assertEqual(self.request.all(), {
'__token': 'testing',
'application': 'Masonite'
})
self.assertEqual(self.request.all(internal_variables=False),
{'application': 'Masonite'})
def test_request_has_should_return_bool(self):
self.assertEqual(self.request.has('application'), True)
self.assertEqual(self.request.has('shouldreturnfalse'), False)
def test_request_has_should_accept_multiple_values(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
self.assertEqual(self.request.has('application'), True)
self.assertEqual(self.request.has('shouldreturnfalse'), False)
self.assertEqual(self.request.has('__token'), True)
self.assertEqual(self.request.has('__token', 'shouldreturnfalse'),
False)
self.assertEqual(self.request.has('__token', 'application'), True)
self.assertEqual(
self.request.has('__token', 'application', 'shouldreturnfalse'),
False)
def test_request_set_params_should_return_self(self):
self.assertEqual(self.request.set_params({'value': 'new'}),
self.request)
self.assertEqual(self.request.url_params, {'value': 'new'})
def test_request_param_returns_parameter_set_or_false(self):
self.request.set_params({'value': 'new'})
self.assertEqual(self.request.param('value'), 'new')
self.assertEqual(self.request.param('nullvalue'), False)
def test_request_appends_cookie(self):
self.assertEqual(self.request.cookie('appendcookie', 'value'),
self.request)
assert 'appendcookie' in self.request.environ['HTTP_COOKIE']
def test_request_sets_and_gets_cookies(self):
self.request.cookie('setcookie', 'value')
self.assertEqual(self.request.get_cookie('setcookie'), 'value')
def test_request_sets_expiration_cookie_2_months(self):
self.request.cookies = []
self.request.cookie('setcookie_expiration',
'value',
expires='2 months')
time = cookie_expire_time('2 months')
self.assertEqual(self.request.get_cookie('setcookie_expiration'),
'value')
self.assertEqual(
self.request.get_raw_cookie('setcookie_expiration')['expires'],
time)
def test_delete_cookie(self):
self.request.cookies = []
self.request.cookie('delete_cookie', 'value')
self.assertEqual(self.request.get_cookie('delete_cookie'), 'value')
self.request.delete_cookie('delete_cookie')
self.assertFalse(self.request.get_cookie('delete_cookie'))
def test_delete_cookie_with_wrong_key(self):
self.request.cookies = []
self.request.cookie('cookie', 'value')
self.request.key('wrongkey_TXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=')
self.assertIsNone(self.request.get_cookie('cookie'))
def test_redirect_returns_request(self):
self.assertEqual(self.request.redirect('newurl'), self.request)
self.assertEqual(self.request.redirect_url, '/newurl')
def test_request_no_input_returns_false(self):
self.assertEqual(self.request.input('notavailable'), False)
def test_request_mini_field_storage_returns_single_value(self):
storages = {'test': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test'), '1')
def test_request_can_get_string_value(self):
storages = {'test': 'value'}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test'), 'value')
def test_request_can_get_list_value(self):
storages = {'test': ['foo', 'bar']}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test'), ['foo', 'bar'])
def test_request_mini_field_storage_doesnt_return_brackets(self):
storages = {'test[]': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test'), '1')
def test_request_mini_field_storage_index(self):
storages = {'test[index]': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test[index]'), '1')
def test_request_mini_field_storage_with_dot_notation(self):
storages = {'test[index]': [MiniFieldStorage('key', '1')]}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test.index'), '1')
def test_request_mini_field_storage_returns_a_list(self):
storages = {
'test':
[MiniFieldStorage('key', '1'),
MiniFieldStorage('key', '2')]
}
self.request._set_standardized_request_variables(storages)
self.assertEqual(self.request.input('test'), ['1', '2'])
def test_request_get_cookies_returns_cookies(self):
self.assertEqual(self.request.get_cookies(), self.request.cookies)
def test_request_set_user_sets_object(self):
self.assertEqual(self.request.set_user(object), self.request)
self.assertEqual(self.request.user_model, object)
self.assertEqual(self.request.user(), object)
def test_request_loads_app(self):
app = App()
app.bind('Request', self.request)
app.make('Request').load_app(app)
self.assertEqual(self.request.app(), app)
self.assertEqual(app.make('Request').app(), app)
def test_request_gets_input_from_container(self):
container = App()
container.bind('Application', application)
container.bind('Providers', providers)
container.bind('WSGI', object)
container.bind('Environ', wsgi_request)
for provider in container.make('Providers').PROVIDERS:
provider().load_app(container).register()
container.bind('Response', 'test')
container.bind('WebRoutes', [
Get().route('url', 'TestController@show'),
Get().route('url/', 'TestController@show'),
Get().route('url/@firstname', 'TestController@show'),
])
container.bind('Response', 'Route not found. Error 404')
for provider in container.make('Providers').PROVIDERS:
located_provider = provider().load_app(container)
container.resolve(located_provider.boot)
self.assertEqual(
container.make('Request').input('application'), 'Masonite')
self.assertEqual(
container.make('Request').all(), {'application': 'Masonite'})
container.make('Request').environ['REQUEST_METHOD'] = 'POST'
self.assertEqual(
container.make('Request').environ['REQUEST_METHOD'], 'POST')
self.assertEqual(
container.make('Request').input('application'), 'Masonite')
def test_redirections_reset(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', WEB_ROUTES)
request = app.make('Request').load_app(app)
request.redirect('test')
self.assertEqual(request.redirect_url, '/test')
request.reset_redirections()
self.assertFalse(request.redirect_url)
request.redirect_to('test')
self.assertEqual(request.redirect_url, '/test')
request.reset_redirections()
self.assertFalse(request.redirect_url)
def test_redirect_to_throws_exception_when_no_routes_found(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', WEB_ROUTES)
request = app.make('Request').load_app(app)
request.redirect_to('test')
request.redirect(name='test')
with pytest.raises(RouteException):
request.redirect_to('notavailable')
with pytest.raises(RouteException):
request.redirect(name='notavailable')
def test_request_has_subdomain_returns_bool(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
self.assertFalse(request.has_subdomain())
self.assertIsNone(request.subdomain)
request.environ['HTTP_HOST'] = 'test.localhost.com'
request.header('TEST', 'set_this')
self.assertEqual(request.header('TEST'), 'set_this')
request.header('TEST', 'set_this', http_prefix=True)
self.assertEqual(request.header('HTTP_TEST'), 'set_this')
def test_redirect_compiles_url(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = '/test/url'
self.assertEqual(request.compile_route_to_url(route), '/test/url')
def test_redirect_compiles_url_with_1_slash(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = '/'
self.assertEqual(request.compile_route_to_url(route), '/')
def test_request_route_returns_url(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'TestController@show').name('test.id')
])
request = app.make('Request').load_app(app)
self.assertEqual(request.route('test.url'), '/test/url')
self.assertEqual(request.route('test.id', {'id': 1}), '/test/url/1')
self.assertEqual(request.route('test.id', [1]), '/test/url/1')
with self.assertRaises(RouteException):
self.assertTrue(request.route('not.exists', [1]))
def test_request_route_returns_url_without_passing_args_with_current_param(
self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'TestController@show').name('test.id')
])
request = app.make('Request').load_app(app)
request.url_params = {'id': 1}
assert request.route('test.id') == '/test/url/1'
def test_request_redirection(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'TestController@testing').name('test.id'),
Get('/test/url/object', TestController.show).name('test.object')
])
request = app.make('Request').load_app(app)
self.assertEqual(
request.redirect('/test/url/@id', {
'id': 1
}).redirect_url, '/test/url/1')
request.redirect_url = None
self.assertEqual(
request.redirect(name='test.url').redirect_url, '/test/url')
request.redirect_url = None
self.assertEqual(
request.redirect(name='test.id', params={
'id': 1
}).redirect_url, '/test/url/1')
request.redirect_url = None
self.assertEqual(
request.redirect(controller='TestController@show').redirect_url,
'/test/url')
request.redirect_url = None
self.assertEqual(
request.redirect(controller=TestController.show).redirect_url,
'/test/url/object')
request.redirect_url = None
self.assertEqual(
request.redirect('some/url').redirect_url, '/some/url')
def test_request_route_returns_full_url(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'TestController@show').name('test.id')
])
request = app.make('Request').load_app(app)
self.assertEqual(request.route('test.url', full=True),
'http://*****:*****@id'
params = {
'id': '1',
}
self.assertEqual(request.compile_route_to_url(route, params),
'/test/1')
def test_redirect_compiles_url_with_list_parameters(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id'
params = ['1']
self.assertEqual(request.compile_route_to_url(route, params),
'/test/1')
route = 'test/@id/@user/test/@slug'
params = ['1', '2', '3']
self.assertEqual(request.compile_route_to_url(route, params),
'/test/1/2/test/3')
def test_redirect_compiles_url_with_multiple_parameters(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id/@test'
params = {
'id': '1',
'test': 'user',
}
self.assertEqual(request.compile_route_to_url(route, params),
'/test/1/user')
def test_request_compiles_custom_route_compiler(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = 'test/@id:signed'
params = {
'id': '1',
}
self.assertEqual(request.compile_route_to_url(route, params),
'/test/1')
def test_redirect_compiles_url_with_http(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
route = "http://google.com"
self.assertEqual(request.compile_route_to_url(route),
'http://google.com')
def test_can_get_nully_value(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request._set_standardized_request_variables({
"gateway": "RENDIMENTO",
"request": {
"user": "******"
},
"response": None,
"description": "test only"
})
self.assertEqual(request.input('response'), None)
def test_request_gets_correct_header(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
self.assertEqual(request.header('HTTP_UPGRADE_INSECURE_REQUESTS'), '1')
self.assertEqual(request.header('RAW_URI'), '/')
self.assertEqual(request.header('NOT_IN'), '')
self.assertFalse('text/html' in request.header('NOT_IN'))
def test_request_sets_correct_header(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.header('TEST', 'set_this')
self.assertEqual(request.header('TEST'), 'set_this')
request.header('TEST', 'set_this', http_prefix=True)
self.assertEqual(request.header('HTTP_TEST'), 'set_this')
def test_request_cant_set_multiple_headers(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.header('TEST', 'test_this')
request.header('TEST', 'test_that')
self.assertEqual(request.header('TEST'), 'test_that')
def test_request_sets_headers_with_dictionary(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.header({
'test_dict': 'test_value',
'test_dict1': 'test_value1'
})
self.assertEqual(request.header('test_dict'), 'test_value')
self.assertEqual(request.header('test_dict1'), 'test_value1')
request.header({
'test_dict': 'test_value',
'test_dict1': 'test_value1'
},
http_prefix=True)
self.assertEqual(request.header('HTTP_test_dict'), 'test_value')
self.assertEqual(request.header('HTTP_test_dict1'), 'test_value1')
def test_request_gets_all_headers(self):
app = App()
app.bind('Request', Request(wsgi_request))
request = app.make('Request').load_app(app)
request.header('TEST1', 'set_this_item')
self.assertEqual(request.get_headers(), [('TEST1', 'set_this_item')])
def test_request_sets_str_status_code(self):
app = App()
app.bind('Request', self.request)
app.bind('StatusCode', 'TestController@show')
request = app.make('Request').load_app(app)
request.status('200 OK')
self.assertEqual(request.get_status_code(), '200 OK')
def test_request_sets_int_status_code(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(500)
self.assertEqual(request.get_status_code(),
'500 Internal Server Error')
def test_request_gets_int_status(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(500)
self.assertEqual(request.get_status(), 500)
def test_can_get_code_by_value(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(500)
self.assertEqual(
request._get_status_code_by_value('500 Internal Server Error'),
500)
def test_is_status_code(self):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(500)
self.assertEqual(request.is_status(500), True)
def test_request_sets_invalid_int_status_code(self):
with self.assertRaises(InvalidHTTPStatusCode):
app = App()
app.bind('Request', self.request)
request = app.make('Request').load_app(app)
request.status(600)
def test_request_sets_request_method(self):
wsgi = generate_wsgi()
wsgi['QUERY_STRING'] = '__method=PUT'
request = Request(wsgi)
assert request.has('__method')
self.assertEqual(request.input('__method'), 'PUT')
self.assertEqual(request.get_request_method(), 'PUT')
def test_request_has_should_pop_variables_from_input(self):
self.request.request_variables.update({'key1': 'test', 'key2': 'test'})
self.request.pop('key1', 'key2')
self.assertEqual(self.request.request_variables,
{'application': 'Masonite'})
self.request.pop('shouldnotexist')
self.assertEqual(self.request.request_variables,
{'application': 'Masonite'})
self.request.pop('application')
self.assertEqual(self.request.request_variables, {})
def test_is_named_route(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'TestController@show').name('test.id')
])
request = app.make('Request').load_app(app)
request.path = '/test/url'
assert request.is_named_route('test.url')
request.path = '/test/url/1'
assert request.is_named_route('test.id', {'id': 1})
def test_route_exists(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'TestController@show').name('test.id')
])
request = app.make('Request').load_app(app)
self.assertEqual(request.route_exists('/test/url'), True)
self.assertEqual(request.route_exists('/test/Not'), False)
def test_request_url_from_controller(self):
app = App()
app.bind('Request', self.request)
app.bind('WebRoutes', [
Get('/test/url', 'TestController@show').name('test.url'),
Get('/test/url/@id', 'ControllerTest@show').name('test.id'),
Get('/test/url/controller/@id',
TestController.show).name('test.controller'),
])
request = app.make('Request').load_app(app)
self.assertEqual(request.url_from_controller('TestController@show'),
'/test/url')
self.assertEqual(
request.url_from_controller('ControllerTest@show', {'id': 1}),
'/test/url/1')
self.assertEqual(
request.url_from_controller(TestController.show, {'id': 1}),
'/test/url/controller/1')
def test_contains_for_path_detection(self):
self.request.path = '/test/path'
self.assertTrue(self.request.contains('/test/*'))
self.assertTrue(self.request.contains('/test/path'))
self.assertFalse(self.request.contains('/test/wrong'))
def test_contains_for_multiple_paths(self):
self.request.path = '/test/path/5'
self.assertTrue(self.request.contains('/test/*'))
def test_contains_can_return_string(self):
self.request.path = '/test/path/5'
self.assertEqual(self.request.contains('/test/*', show='active'),
'active')
self.assertEqual(self.request.contains('/test/not', show='active'), '')
def test_contains_for_path_with_digit(self):
self.request.path = '/test/path/1'
self.assertTrue(self.request.contains('/test/path/*'))
self.assertTrue(self.request.contains('/test/path/*:int'))
def test_contains_for_path_with_digit_and_wrong_contains(self):
self.request.path = '/test/path/joe'
self.assertFalse(self.request.contains('/test/path/*:int'))
def test_contains_for_path_with_alpha_contains(self):
self.request.path = '/test/path/joe'
self.assertTrue(self.request.contains('/test/path/*:string'))
def test_contains_for_route_compilers(self):
self.request.path = '/test/path/joe'
self.assertTrue(self.request.contains('/test/path/*:signed'))
def test_contains_multiple_asteriks(self):
self.request.path = '/dashboard/user/edit/1'
self.assertTrue(
self.request.contains('/dashboard/user/*:string/*:int'))
def test_request_can_get_input_as_properties(self):
self.request.request_variables = {'test': 'hey'}
self.assertEqual(self.request.test, 'hey')
self.assertEqual(self.request.input('test'), 'hey')
def test_request_can_get_param_as_properties(self):
self.request.url_params = {'test': 'hey'}
self.assertEqual(self.request.test, 'hey')
self.assertEqual(self.request.param('test'), 'hey')
def test_back_returns_correct_url(self):
self.request.path = '/dashboard/create'
self.request.back()
self.assertEqual(self.request.redirect_url, '/dashboard/create')
self.request.back(default='/home')
self.assertEqual(self.request.redirect_url, '/home')
self.request.request_variables = {'__back': '/login'}
self.request.back(default='/home')
self.assertEqual(self.request.redirect_url, '/login')
def test_request_without(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
self.assertEqual(self.request.without('__token'),
{'application': 'Masonite'})
def test_request_only_returns_specified_values(self):
self.request.request_variables.update({
'__token': 'testing',
'application': 'Masonite'
})
self.assertEqual(self.request.only('application'),
{'application': 'Masonite'})
self.assertEqual(self.request.only('__token'), {'__token': 'testing'})
def test_request_gets_only_clean_output(self):
self.request._set_standardized_request_variables(
{'key': '<img """><script>alert(\'hey\')</script>">'})
self.assertEqual(
self.request.input('key'),
'<img """><script>alert('hey')</script>">'
)
self.assertEqual(self.request.input('key', clean=False),
'<img """><script>alert(\'hey\')</script>">')
def test_request_cleans_all_optionally(self):
self.request._set_standardized_request_variables(
{'key': '<img """><script>alert(\'hey\')</script>">'})
self.assertEqual(
self.request.all()['key'],
'<img """><script>alert('hey')</script>">'
)
self.assertEqual(
self.request.all(clean=False)['key'],
'<img """><script>alert(\'hey\')</script>">')
def test_request_gets_input_with_dotdict(self):
self.request.request_variables = {
"key": {
"user": "******",
"name": "Joe",
"address": {
"street": "address 1"
}
}
}
self.assertEqual(
self.request.input('key')['address']['street'], 'address 1')
self.assertEqual(self.request.input('key.address.street'), 'address 1')
self.assertEqual(self.request.input('key.'), False)
self.assertEqual(self.request.input('key.user'), '1')
self.assertEqual(self.request.input('key.nothing'), False)
self.assertEqual(self.request.input('key.nothing', default='test'),
'test')
class TestAuth(TestCase):
"""Start and rollback transactions for this test
"""
transactions = True
def setUp(self):
super().setUp()
self.container = App()
self.app = self.container
self.app.bind('Container', self.app)
view = View(self.container)
self.request = Request(generate_wsgi())
self.request.key(application.KEY)
self.app.bind('Request', self.request)
# self.auth = Auth(self.request, MockUser())
self.container.bind('View', view.render)
self.container.bind('ViewClass', view)
self.app.bind('Application', application)
self.app.bind('Auth', Auth)
self.app.bind('AuthConfig', auth)
self.app.bind('AuthManager', AuthManager)
self.app.bind('AuthCookieDriver', AuthCookieDriver)
self.app.bind('AuthJwtDriver', AuthJwtDriver)
self.auth = self.app.make('Auth', User)
self.request.load_app(self.app)
def setUpFactories(self):
User.create({
'name': 'testuser123',
'email': '*****@*****.**',
'password': bcrypt_password('secret'),
'second_password': bcrypt_password('pass123'),
})
def test_auth(self):
self.assertTrue(self.auth)
def test_login_user(self):
for driver in ('cookie', 'jwt'):
self.auth.driver = driver
self.assertTrue(self.auth.login('*****@*****.**', 'secret'))
self.assertTrue(self.request.get_cookie('token'))
self.assertEqual(self.auth.user().name, 'testuser123')
def test_login_with_no_password(self):
with self.assertRaises(TypeError):
for driver in ('cookie', 'jwt'):
self.auth.driver = driver
self.assertTrue(self.auth.login('*****@*****.**', None))
# def test_can_login_with_second_password(self):
# self.auth.auth_model.__password__ = 'second_password'
# self.assertTrue(self.auth.login('*****@*****.**', 'pass123'))
# self.assertTrue(self.request.get_cookie('token'))
def test_login_user_with_list_auth_column(self):
for driver in ('cookie', 'jwt'):
self.auth.driver = driver
self.auth.auth_model.__auth__ = ['name', 'email']
self.assertTrue(self.auth.login('testuser123', 'secret'))
self.assertTrue(self.request.get_cookie('token'))
def test_can_register(self):
self.auth.register({
'name': 'Joe',
'email': '*****@*****.**',
'password': '******'
})
for driver in ('cookie', 'jwt'):
self.auth.driver = driver
self.assertTrue(User.where('email', '*****@*****.**').first())
self.assertNotEqual(User.where('email', '*****@*****.**').first().password, 'secret')
def test_get_user(self):
for driver in ('cookie', 'jwt'):
self.auth.driver = driver
self.assertTrue(self.auth.login_by_id(1))
def test_get_user_returns_false_if_not_loggedin(self):
for driver in ('cookie', 'jwt'):
self.auth.driver = driver
self.auth.login('*****@*****.**', 'wrong_secret')
self.assertFalse(self.auth.user())
def test_logout_user(self):
for driver in ('cookie', 'jwt'):
self.auth.driver = driver
self.auth.login('*****@*****.**', 'secret')
self.assertTrue(self.request.get_cookie('token'))
self.assertTrue(self.auth.user())
self.auth.logout()
self.assertFalse(self.request.get_cookie('token'))
self.assertFalse(self.auth.user())
def test_login_user_fails(self):
for driver in ('cookie', 'jwt'):
self.auth.driver = driver
self.assertFalse(self.auth.login('*****@*****.**', 'bad_password'))
def test_login_user_success(self):
for driver in ('cookie', 'jwt'):
self.auth.driver = driver
self.assertTrue(self.auth.login('*****@*****.**', 'secret'))
def test_login_by_id(self):
for driver in ('cookie', 'jwt'):
self.auth.driver = driver
self.assertTrue(self.auth.login_by_id(1))
self.assertTrue(self.request.get_cookie('token'))
self.assertFalse(self.auth.login_by_id(3))
def test_login_once_does_not_set_cookie(self):
for driver in ('cookie', 'jwt'):
self.auth.driver = driver
self.assertTrue(self.auth.once().login_by_id(1))
self.assertIsNone(self.request.get_cookie('token'))
# def test_user_is_mustverify_instance(self):
# self.assertIsInstance(self.auth.once().login_by_id(1), MustVerifyEmail)
# self.assertNotIsInstance(self.auth.once().login_by_id(1), MustVerifyEmail)
def test_confirm_controller_success(self):
for driver in ('jwt', 'cookie'):
self.auth.driver = driver
params = {'id': Sign().sign('{0}::{1}'.format(1, time.time()))}
self.request.set_params(params)
user = self.auth.once().login_by_id(1)
self.request.set_user(user)
self.app.bind('Request', self.request)
self.app.make('Request').load_app(self.app)
# Create the route
route = Get('/email/verify/@id', ConfirmController.confirm_email)
ConfirmController.get_user = User
# Resolve the controller constructor
controller = self.app.resolve(route.controller)
# Resolve the method
response = self.app.resolve(getattr(controller, route.controller_method))
self.assertEqual(response.rendered_template, 'confirm')
self.refreshDatabase()
def test_confirm_controller_failure(self):
for driver in ('cookie', 'jwt'):
self.auth.driver = driver
timestamp_plus_11 = datetime.datetime.now() - datetime.timedelta(minutes=11)
params = {'id': Sign().sign('{0}::{1}'.format(1, timestamp_plus_11.timestamp()))}
self.request.set_params(params)
user = self.auth.once().login_by_id(1)
self.request.set_user(user)
self.app.bind('Request', self.request)
self.app.make('Request').load_app(self.app)
# Create the route
route = Get('/email/verify/@id', ConfirmController.confirm_email)
ConfirmController.get_user = User
# Resolve the controller constructor
controller = self.app.resolve(route.controller)
# Resolve the method
response = self.app.resolve(getattr(controller, route.controller_method))
self.assertEqual(response.rendered_template, 'error')
def setup_method(self):
self.request = Request(generate_wsgi())
self.request.request_variables = {'id': '1'}
