def test_flatten_flattens_multiple_lists(self):
routes = [
Get().route('/test/1', 'TestController@show').name('create'),
RouteGroup([
Get().route('/test/1', 'TestController@show').name('create'),
Get().route('/test/2', 'TestController@show').name('edit'),
RouteGroup([
Get().route('/test/1',
'TestController@show').name('update'),
Get().route('/test/2',
'TestController@show').name('delete'),
RouteGroup([
Get().route('/test/3',
'TestController@show').name('update'),
Get().route('/test/4',
'TestController@show').name('delete'),
],
middleware=('auth')),
],
name='post.')
],
prefix='/dashboard')
]
routes = flatten_routes(routes)
assert routes[3].route_url == '/dashboard/test/1'
assert routes[3].named_route == 'post.update'
def test_view_returns_with_route_view(self):
self.app.make('Route').url = '/test/route'
self.app.bind('WebRoutes',
[Get().view('/test/route', 'test', {'test': 'testing'})])
self.provider.boot(self.app.make('Route'), self.app.make('Request'),
self.app.make(Response))
assert self.app.make('Response') == 'testing'
def test_can_use_resolving_params_and_object(self):
self.app.make('Route').url = '/test/1'
self.app.bind('WebRoutes',
[Get('/test/@id', ControllerTest.get_param_and_object)])
self.provider.boot(self.app.make('Route'), self.app.make('Request'),
self.app.make(Response))
self.assertEqual(self.app.make('Request').first, '1')
def test_can_call_container_with_annotations_from_variable():
app = App()
request = Request(wsgi_request)
app.bind('Request', request)
app.bind('Get', Get().route('url', None))
assert app.resolve(ContainerTest().testboot) == app.make('Request')
def setup_method(self):
super().setup_method()
self.routes([
Get().route(
'/testing',
'TestController@show').name('testing.route').middleware(
'auth', 'owner')
])
def setUp(self):
super().setUp()
self.routes(only=[
Get('/', 'ControllerTest@show').middleware('csrf'),
Post('/test-route', 'ControllerTest@show').middleware('csrf')
])
csrf = CsrfMiddleware
csrf.exempt = ['/*']
self.withRouteMiddleware({'csrf': csrf})
def test_method_type_has_required_subdomain():
get = Get().domain('test')
post = Get().domain('test')
REQUEST.environ['HTTP_HOST'] = 'test.localhost:8000'
get.request = REQUEST
post.request = REQUEST
assert get.has_required_domain() == True
assert post.has_required_domain() == True
def test_providers_load_into_container(self):
for provider in self.app.make('Providers').PROVIDERS:
self.app.resolve(provider().load_app(self.app).register)
self.app.bind('Response', 'test')
self.app.bind('WebRoutes', [
Get().route('url', None),
Get().route('url/', None),
Get().route('url/@firstname', None),
])
self.app.bind('Response', 'Route not found. Error 404')
for provider in self.app.make('Providers').PROVIDERS:
provider().load_app(self.app)
self.app.resolve(provider().load_app(self.app).boot)
assert self.app.make('Request')
def test_group_route_sets_middleware(self):
routes = RouteGroup([
Get().route('/test/1',
'TestController@show').middleware('another'),
Get().route('/test/2', 'TestController@show'),
RouteGroup([
Get().route('/test/3', 'TestController@show'),
Get().route('/test/4', 'TestController@show')
],
middleware=('test', 'test2'))
],
middleware=('auth', 'user'))
self.assertIsInstance(routes, list)
self.assertEqual(['another', 'auth', 'user'],
routes[0].list_middleware)
self.assertEqual(['auth', 'user'], routes[1].list_middleware)
self.assertEqual(['test', 'test2', 'auth', 'user'],
routes[2].list_middleware)
def test_custom_route_compiler_returns_param(self):
self.app.make('Route').url = '/test/1'
self.app.make('Route').compile('signed', r'([\w.-]+)')
self.app.bind('WebRoutes',
[Get('/test/@id:signed', ControllerTest.param)])
self.provider.boot(self.app.make('Route'), self.app.make('Request'),
self.app.make(Response))
self.assertEqual(self.app.make('Response'), '1')
def test_url_with_dashes_finds_route(self):
self.app.make('Route').url = '/test/user-endpoint'
self.app.bind('WebRoutes',
[Get('/test/@endpoint', ControllerTest.test)])
self.provider.boot(self.app.make('Route'), self.app.make('Request'),
self.app.make(Response))
self.assertEqual(
self.app.make('Request').param('endpoint'), 'user-endpoint')
def test_provider_runs_through_routes(self):
self.app.make('Route').url = '/test'
self.app.bind('WebRoutes', [Get('/test', ControllerTest.test)])
self.provider.boot(self.app.make('Route'), self.app.make('Request'),
self.app.make(Response))
self.assertEqual(
self.app.make('Request').header('Content-Type'),
'text/html; charset=utf-8')
def test_route_can_add_compilers(self):
get_route = Get().route('test/@route:int', None)
self.assertEqual(get_route.compile_route_to_regex(), r'^\/test\/(\d+)\/$')
self.route.compile('year', r'[0-9]{4}')
get_route = Get().route('test/@route:year', None)
self.assertEqual(get_route.compile_route_to_regex(), r'^\/test\/[0-9]{4}\/$')
with self.assertRaises(InvalidRouteCompileException):
get_route = Get().route('test/@route:none', None)
create_matchurl('/test/1', get_route)
def test_controller_returns_json_response_for_dict(self):
self.app.make('Route').url = '/view'
self.app.bind('WebRoutes',
[Get('/view', ControllerTest.returns_a_dict)])
self.provider.boot(self.app.make('Route'), self.app.make('Request'),
self.app.make(Response))
self.assertEqual(
self.app.make('Request').header('Content-Type'),
'application/json; charset=utf-8')
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_providers_load_into_container():
for provider in container.make('Application').PROVIDERS:
container.resolve(locate(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('Application').PROVIDERS:
located_provider = locate(provider)().load_app(container)
container.resolve(locate(provider)().load_app(container).boot)
assert container.make('Request')
def test_route_can_pass_route_values_in_constructor(self):
route = Get('test/url', 'BreakController@show')
assert route.route_url == 'test/url'
route = Post('test/url', 'BreakController@show')
assert route.route_url == 'test/url'
route = Put('test/url', 'BreakController@show')
assert route.route_url == 'test/url'
route = Patch('test/url', 'BreakController@show')
assert route.route_url == 'test/url'
route = Delete('test/url', 'BreakController@show')
assert route.route_url == 'test/url'
def test_route_runs_str_middleware(self):
self.app.make('Route').url = '/view'
self.app.bind('RouteMiddleware', middleware.ROUTE_MIDDLEWARE)
self.app.bind(
'WebRoutes',
[Get('/view', ControllerTest.returns_a_dict).middleware('test')])
self.provider.boot(self.app.make('Route'), self.app.make('Request'),
self.app.make(Response))
self.assertEqual(
self.app.make('Request').path, 'test/middleware/before/ran')
def get(url, controller):
"""Shortcut for Get HTTP class.
Arguments:
url {string} -- The url you want to use for the route
controller {string|object} -- This can be a string controller or a normal object controller
Returns:
masonite.routes.Get -- The Masonite Get class.
"""
return Get().route(url, controller)
def test_method_type_has_required_subdomain_with_asterick():
container = TestSuite().create_container()
request = container.container.make('Request')
request.environ['HTTP_HOST'] = 'test.localhost:8000'
get = Get().domain('*')
post = Get().domain('*')
get.request = request
post.request = request
assert get.has_required_domain() == True
assert post.has_required_domain() == True
def test_route_subdomain_ignores_routes(self):
self.app.make('Route').url = '/test'
self.app.make('Environ')['HTTP_HOST'] = 'subb.domain.com'
self.app.bind('WebRoutes', [Get('/test', ControllerTest.test)])
request = self.app.make('Request')
request.activate_subdomains()
self.provider.boot(self.app.make('Route'), self.app.make('Request'),
self.app.make(Response))
self.assertEqual(self.app.make('Response'),
'Route not found. Error 404')
def test_request_sets_subdomain_on_get():
container = TestSuite().create_container()
request = container.container.make('Request')
request.environ['HTTP_HOST'] = 'test.localhost:8000'
get = Get().domain('*')
post = Get().domain('*')
get.request = request
post.request = request
get.has_required_domain()
assert request.param('subdomain') == 'test'
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_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
assert get.has_required_domain() == True
assert post.has_required_domain() == True
def setUp(self):
super().setUp()
self.routes(only=[
Get('/user/?name', 'TestController@v').name('user.name'),
Get('/multiple/user/?name/?last', 'TestController@v').name('user.multiple'),
Get('/default/user/?name', 'TestController@v').default({'name': 'Joseph'}),
Get('/back/user/name?', 'TestController@v'),
Get('/back/default/user/?name', 'TestController@v').default({'name': 'Joseph'}),
Get('/optional/?name:int', 'TestController@v'),
])
def test_route_can_pass_route_values_in_constructor(self):
route = Get('test/url', 'BreakController@show')
self.assertEqual(route.route_url, '/test/url')
route = Head('test/url', 'BreakController@show')
self.assertEqual(route.route_url, '/test/url')
route = Post('test/url', 'BreakController@show')
self.assertEqual(route.route_url, '/test/url')
route = Put('test/url', 'BreakController@show')
self.assertEqual(route.route_url, '/test/url')
route = Patch('test/url', 'BreakController@show')
self.assertEqual(route.route_url, '/test/url')
route = Delete('test/url', 'BreakController@show')
self.assertEqual(route.route_url, '/test/url')
route = Connect('test/url', 'BreakController@show')
self.assertEqual(route.route_url, '/test/url')
route = Options('test/url', 'BreakController@show')
self.assertEqual(route.route_url, '/test/url')
route = Trace('test/url', 'BreakController@show')
self.assertEqual(route.route_url, '/test/url')
def setup_method(self):
self.app = App()
self.app.bind('Environ', generate_wsgi())
self.app.bind('Application', application)
self.app.make('Environ')
self.app.bind('StatusCode', '404 Not Found Error')
self.app.bind('Request',
Request(self.app.make('Environ')).load_app(self.app))
self.app.simple(Response(self.app))
self.app.bind('Csrf', Csrf(self.app.make('Request')))
self.app.bind('Route', Route(self.app.make('Environ')))
self.app.bind('ViewClass', View(self.app))
self.app.bind(
'WebRoutes',
[Get().route('/', 'TestController@show').middleware('test')])
self.app.bind('HttpMiddleware', [MiddlewareHttpTest])
self.app.bind('RouteMiddleware', {'test': MiddlewareTest})
self.provider = RouteProvider()
self.provider.app = self.app
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()
"""Admin Routes."""
from masonite.routes import Get, Post, RouteGroup
from admin.web.admin_controller import ADMIN_STATIC_DIR_PATH, AdminController
from admin.web.admin_resources import AdminResource
from admin.web.login_controller import LoginController
from config.admin import MODELS
from config.storage import STATICFILES
STATICFILES[ADMIN_STATIC_DIR_PATH] = '/'
ADMIN_ROUTES_WITH_MIDDLEWARE = [
Get().route('/api/info', AdminController.info),
Get().route('/api/schema/@model', AdminController.schema),
Get().route('/api/schema/@model/create', AdminController.create),
Get().route('/api/schema/@model/detail', AdminController.detail),
Get().route('/api/create_display/@model', AdminController.create_display),
]
MODEL_ROUTES = []
for model in MODELS:
args = {}
if model.get('list_display'):
args['list_display'] = model['list_display']
if model.get('detail_display'):
args['detail_display'] = model['detail_display']
MODEL_ROUTES.append(AdminResource(model['model'], **args).routes())
ADMIN_ROUTES = [
