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)