def send_verify_email(self, manager: MailManager, request: Request):
user = request.user()
if isinstance(user, MustVerifyEmail):
user.verify_email(manager, request)
return request.redirect('/home')
def setUp(self):
self.app = App()
self.request = Request(wsgi_request.copy()).key(
'NCTpkICMlTXie5te9nJniMj9aVbPM6lsjeq5iDZ0dqY=').load_app(self.app)
self.app.bind('Request', self.request)
self.response = Response(self.app)
self.app.simple(Response)
def test_pipeline_exits(self):
request = Request({})
request2 = Request({})
pipeline = Pipeline(request, request2).through([PipeTestOne, PipeTestBreak])
self.assertTrue(request.one == 1)
with self.assertRaises(AttributeError):
self.assertTrue(request.two == 2)
def test_pipeline_sets_attributes(self):
request = Request({})
request2 = Request({})
pipeline = Pipeline(request,
request2).through([PipeTestOne, PipeTestTwo])
self.assertTrue(request.one == 1)
self.assertTrue(request.two == 2)
def store_changed_password(
self, auth: Auth, request: Request, response: Response
): # store password_reset record
auth.reset_password(request.input("password"), request.input("token"))
# Need to validate??
# Redirect back?
return response.back()
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 store(self, view: View, request: Request, auth: Auth, response: Response):
login = auth.attempt(request.input("username"), request.input("password"))
if login:
return response.redirect(name="home")
# Go back to login page
return response.redirect(name="login")
def test_redirect_route(self):
route = Redirect('/test1', '/test2')
request = Request(generate_wsgi())
route.load_request(request)
request.load_app(App())
route.get_response()
self.assertTrue(request.is_status(302))
self.assertEqual(request.redirect_url, '/test2')
def test_redirect_can_use_301(self):
request = Request(generate_wsgi())
route = Redirect('/test1', '/test3', status=301)
route.load_request(request)
request.load_app(App())
route.get_response()
self.assertTrue(request.is_status(301))
self.assertEqual(request.redirect_url, '/test3')
def test_get_json_input(self):
json_wsgi = wsgi_request
json_wsgi['REQUEST_METHOD'] = 'POST'
json_wsgi['CONTENT_TYPE'] = 'application/json'
json_wsgi['POST_DATA'] = ''
json_wsgi['wsgi.input'] = MockWsgiInput('{"id": 1, "test": "testing"}')
Route(json_wsgi)
request_obj = Request(json_wsgi)
self.assertIsInstance(request_obj.request_variables, dict)
self.assertEqual(request_obj.input('id'), 1)
self.assertEqual(request_obj.input('test'), 'testing')
class TestViewHelpers(unittest.TestCase):
def setUp(self):
self.app = App()
self.view = View(self.app)
self.request = Request(generate_wsgi()).load_app(self.app)
self.provider = HelpersProvider()
self.provider.load_app(self.app).boot(self.view, self.request)
def test_boot_added_view_shares(self):
self.assertGreater(len(self.view._shared), 1)
def test_request_view_helper_is_view_class(self):
self.assertIsInstance(self.view._shared['request'](), Request)
def test_auth_returns_user_and_none(self):
self.assertIsNone(self.view._shared['auth']())
self.request.set_user(MockUser)
self.assertEqual(self.view._shared['auth']().id, 1)
def test_request_method_returns_hidden_input(self):
self.assertEqual(self.view._shared['request_method']('PUT'),
"<input type='hidden' name='__method' value='PUT'>")
def test_can_sign_and_encrypt(self):
self.assertNotEqual(self.view._shared['sign']('secret'), 'secret')
self.assertGreater(len(self.view._shared['sign']('secret')), 10)
self.assertNotEqual(self.view._shared['encrypt']('secret'), 'secret')
self.assertGreater(len(self.view._shared['encrypt']('secret')), 10)
def test_can_unsign_and_decrypt(self):
signed = self.view._shared['sign']('secret')
self.assertEqual(self.view._shared['decrypt'](signed), 'secret')
self.assertEqual(self.view._shared['unsign'](signed), 'secret')
def test_can_get_config(self):
self.assertEqual(self.view._shared['config']('cache.driver'), 'disk')
def test_optional(self):
self.assertEqual(self.view._shared['optional'](MockUser).id, 1)
self.assertNotEqual(self.view._shared['optional'](MockUser).test, 1)
def test_cookie(self):
self.request.cookie('test', 'value')
self.assertEqual(self.view._shared['cookie']('test'), 'value')
def test_hidden(self):
self.assertEqual(self.view._shared['hidden']('test', name='form1'),
"<input type='hidden' name='form1' value='test'>")
class TestRequest(TestCase):
def setUp(self):
self.request = Request(generate_wsgi({"PATH_INFO": "/test"}))
def test_request_no_input_returns_false(self):
self.assertEqual(self.request.input("notavailable"), False)
def test_request_can_get_string_value(self):
storages = {"test": "value"}
self.request.input_bag.query_string = storages
self.assertEqual(self.request.input("test"), "value")
def test_request_can_get_list_value(self):
storages = {"test": ["foo", "bar"]}
self.request.input_bag.query_string = storages
self.assertEqual(self.request.input("test"), ["foo", "bar"])
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 setUp(self):
self.request = Request(generate_wsgi())
self.middleware = MaintenanceModeMiddleware(self.request)
down_path = os.path.join(application.BASE_DIRECTORY, 'bootstrap/down')
down = os.path.exists(down_path)
if down:
os.remove(down_path)
def test_gets_input_and_query_with_non_get_request(self):
app = App()
for method in ['POST', 'PUT', 'DELETE']:
wsgi_environ = generate_wsgi()
wsgi_environ['REQUEST_METHOD'] = method
wsgi_environ[
'QUERY_STRING'] = 'param=1¶m=2¶m=3&foo=bar&q=yes'
wsgi_environ['wsgi.input'] = MockWsgiInput(
'{"param": "hey", "foo": [9, 8, 7, 6], "bar": "baz"}')
wsgi_environ['CONTENT_TYPE'] = 'application/json'
route_class = Route(wsgi_environ)
request_class = Request(wsgi_environ)
app.bind('Request', request_class)
app.bind('Route', route_class)
request = app.make('Request').load_app(app)
self.assertEqual(request.input('foo'), [9, 8, 7, 6])
self.assertEqual(request.input('param'), 'hey')
self.assertEqual(request.input('not-exist', default=2), 2)
self.assertEqual(request.input('q', default='default'), 'default')
self.assertEqual(request.input('bar', default='default'), 'baz')
self.assertEqual(request.query('foo'), 'bar')
self.assertEqual(request.query('param'), '1')
self.assertEqual(request.query('param', multi=True),
['1', '2', '3'])
self.assertEqual(request.query('not-exist', default=2), 2)
self.assertEqual(request.query('not-exist', default=2, multi=True),
2)
self.assertEqual(request.query('q', default='default'), 'yes')
def test_gets_input_and_query_with_get_request(self):
app = App()
wsgi_environ = generate_wsgi()
wsgi_environ['QUERY_STRING'] = 'param=1¶m=2¶m=3&foo=bar&q=yes'
wsgi_environ['wsgi.input'] = {
'param': 'hey',
'foo': [9, 8, 7, 6],
'bar': 'baz'
}
wsgi_environ['REQUEST_METHOD'] = 'GET'
route_class = Route(wsgi_environ)
request_class = Request(wsgi_environ)
app.bind('Request', request_class)
app.bind('Route', route_class)
request = app.make('Request').load_app(app)
self.assertEqual(request.query('param'), '1')
self.assertEqual(request.all_query()['param'], ['1', '2', '3'])
self.assertEqual(request.query('foo'), 'bar')
self.assertEqual(request.query('param', multi=True), ['1', '2', '3'])
self.assertEqual(request.query('not-exist', default=2), 2)
self.assertEqual(request.query('not-exist', default=2, multi=True), 2)
self.assertEqual(request.query('q', default='no'), 'yes')
self.assertEqual(request.input('foo'), 'bar')
self.assertEqual(request.input('param'), '1')
self.assertEqual(request.input('q', default='no'), 'yes')
self.assertEqual(request.input('bar', default='default'), 'default')
def test_can_call_container_with_annotations_from_variable(self):
request = Request(generate_wsgi())
self.container.bind('Request', request)
self.container.bind('Get', Get().route('url', None))
self.assertEqual(self.container.resolve(ContainerTest().testboot),
self.container.make('Request'))
def store(self, auth: Auth, request: Request,
response: Response): # store register user
user = auth.register(request.only("name", "email", "password"))
if not user:
return response.redirect("/register")
return response.redirect("/home")
def test_can_pass_variables(self):
app = App()
req = Request()
app.bind('Request', req)
obj = app.resolve(self._test_resolves_variables, 'test1', 'test2')
self.assertEqual(obj[0], 'test1')
self.assertEqual(obj[1], req)
self.assertEqual(obj[2], 'test2')
def test_hidden_form_request_method_changes_request_method(self):
app = App()
wsgi_request['POST_DATA'] = '__method=PUT'
request_class = Request(wsgi_request)
app.bind('Request', request_class)
request = app.make('Request').load_app(app)
self.assertEqual(request.environ['REQUEST_METHOD'], 'PUT')
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()).load_environ(generate_wsgi())
self.request.key(application.KEY)
self.app.bind('Request', self.request)
self.container.bind('View', view.render)
self.container.bind('ViewClass', view)
self.auth = Guard(self.app)
self.auth.register_guard('web', WebGuard)
self.auth.guard('web').register_driver('jwt', AuthJwtDriver)
self.auth.set('web')
self.app.swap(Auth, self.auth)
self.request.load_app(self.app)
class TestRequest(TestCase):
def setUp(self):
super().setUp()
self.request = Request(generate_wsgi(path="/test"))
def test_request_no_input_returns_false(self):
self.assertEqual(self.request.input("notavailable"), False)
def test_request_can_get_string_value(self):
self.request.input_bag.query_string = {"test": "value"}
self.assertEqual(self.request.input("test"), "value")
def test_request_can_get_list_value(self):
self.request.input_bag.query_string = {"test": ["foo", "bar"]}
self.assertEqual(self.request.input("test"), ["foo", "bar"])
def test_request_can_get_float_value(self):
self.request.input_bag.query_string = {"test": 3.1415926}
self.assertEqual(self.request.input("test"), 3.1415926)
class TestSecureHeadersMiddleware(TestCase):
def setUp(self):
super().setUp()
self.request = Request(generate_wsgi())
self.middleware = SecureHeadersMiddleware(self.request)
self.container.bind('Request', self.request.load_app(self.container))
self.request = self.container.make('Request')
def test_secure_headers_middleware(self):
self.middleware.after()
self.assertEqual(self.request.header('Strict-Transport-Security'),
'max-age=63072000; includeSubdomains')
self.assertEqual(self.request.header('X-Frame-Options'), 'SAMEORIGIN')
def test_secure_headers_gets_middleware_from_the_config(self):
self.request = self.container.make('Request')
self.middleware.after()
self.assertEqual(self.request.header('X-Content-Type-Options'),
'sniff-test')
def test_gets_input_with_all_request_methods(self):
app = App()
wsgi_request['QUERY_STRING'] = 'hey=test'
request_class = Request(wsgi_request)
app.bind('Request', request_class)
request = app.make('Request').load_app(app)
request.environ['REQUEST_METHOD'] = 'GET'
self.assertEqual(request.input('hey'), 'test')
request.environ['REQUEST_METHOD'] = 'POST'
self.assertEqual(request.input('hey'), 'test')
request.environ['REQUEST_METHOD'] = 'PUT'
self.assertEqual(request.input('hey'), 'test')
request.environ['REQUEST_METHOD'] = 'PATCH'
self.assertEqual(request.input('hey'), 'test')
request.environ['REQUEST_METHOD'] = 'DELETE'
self.assertEqual(request.input('hey'), 'test')
def test_list_as_root_payload_reset_between_requests(self):
app = App()
wsgi_environ = generate_wsgi()
wsgi_environ['REQUEST_METHOD'] = 'POST'
wsgi_environ['CONTENT_TYPE'] = 'application/json'
route_class = Route()
request_class = Request()
app.bind('Request', request_class)
app.bind('Route', route_class)
route = app.make('Route')
request = app.make('Request').load_app(app)
wsgi_environ['wsgi.input'] = MockWsgiInput('[1, 2]')
route.load_environ(wsgi_environ)
request.load_environ(wsgi_environ)
self.assertEqual(request.all(), [1, 2])
wsgi_environ['wsgi.input'] = MockWsgiInput('{"key": "val"}')
route.load_environ(wsgi_environ)
request.load_environ(wsgi_environ)
self.assertEqual(request.all(), {"key": "val"})
def confirm_email(self, request: Request, view: View, auth: Auth):
"""Confirm User email and show the correct response.
Arguments:
request {masonite.request.request} -- The Masonite request class.
request {masonite.view.view} -- The Masonite view class.
request {masonite.auth.auth} -- The Masonite Auth class.
Returns:
[type] -- [description]
"""
sign = Sign()
token = sign.unsign(request.param('id'))
if token is not None:
tokenParts = token.split("::")
if len(tokenParts) > 1:
user = auth.auth_model.find(tokenParts[0])
if user.verified_at is None:
timestamp = datetime.datetime.fromtimestamp(
float(tokenParts[1]))
now = datetime.datetime.now()
timestamp_plus_10 = timestamp + datetime.timedelta(
minutes=10)
if now < timestamp_plus_10:
user.verified_at = datetime.datetime.now()
user.save()
return view.render('auth/confirm', {
'app': config('application'),
'Auth': auth
})
return view.render('auth/error', {
'app': config('application'),
'Auth': auth
})
from src.masonite.app import App
from src.masonite.request import Request
from src.masonite.testing 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)
self.app.bind('MockMail', MockMail)
def setUp(self):
self.route = Route(generate_wsgi())
self.request = Request(generate_wsgi())
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()).load_environ(generate_wsgi())
self.request.key(application.KEY)
self.app.bind('Request', self.request)
self.container.bind('View', view.render)
self.container.bind('ViewClass', view)
self.auth = Guard(self.app)
self.auth.register_guard('web', WebGuard)
self.auth.guard('web').register_driver('jwt', AuthJwtDriver)
self.auth.set('web')
self.app.swap(Auth, self.auth)
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_user1(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.auth.driver = driver
self.assertTrue(self.auth.login('*****@*****.**', None))
def test_guard_switches_guard(self):
self.assertIsInstance(self.auth.guard('web'), WebGuard)
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))
self.assertTrue(self.request.user())
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.assertTrue(self.request.user())
self.auth.driver('jwt')
self.auth.logout()
self.assertFalse(self.request.get_cookie('token'))
self.assertFalse(self.auth.user())
self.assertFalse(self.request.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_guard_can_register_new_drivers(self):
self.auth.guard('web').register_driver('api', AuthJwtDriver)
self.assertIsInstance(self.auth.driver('api'), AuthJwtDriver)
def test_guard_can_register_new_guards(self):
self.auth.register_guard('api_guard', AuthJwtDriver)
self.assertIsInstance(self.auth.guard('api_guard'), AuthJwtDriver)
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_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(self):
self.app = App()
self.view = View(self.app)
self.request = Request(generate_wsgi()).load_app(self.app)
self.provider = HelpersProvider()
self.provider.load_app(self.app).boot(self.view, self.request)
