def test_request_gets_input_from_container(self):
container = App()
container.bind('WSGI', object)
container.bind('Environ', wsgi_request)
for provider in config('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 config('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_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')
class TestController(unittest.TestCase):
def setUp(self):
self.app = App()
self.app.bind('object', object)
def test_string_controller_constructor_resolves_container(self):
self.app.bind('Request', Request)
# Create the route
route = get('/url', 'ControllerTest@show')
# Resolve the controller constructor
controller = self.app.resolve(route.controller)
# Resolve the method
response = self.app.resolve(
getattr(controller, route.controller_method))
self.assertIsInstance(route.controller, ControllerTest.__class__)
self.assertEqual(route.controller_method, 'show')
self.assertIsInstance(response, Request)
def test_object_controller_constructor_resolves_container(self):
self.app.bind('Request', Request)
# Create the route
route = get('/url', ControllerTest.show)
# Resolve the controller constructor
controller = self.app.resolve(route.controller)
# Resolve the method
response = self.app.resolve(
getattr(controller, route.controller_method))
self.assertIsInstance(route.controller, ControllerTest.__class__)
self.assertEqual(route.controller_method, 'show')
self.assertIsInstance(response, 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)
mockmail = self.app.make('MockMail')
self.assertIsInstance(mockmail.request, Request)
def test_app_makes_different_instances(self):
self.app.bind('MockMail', MockMail)
self.app.bind('Request', REQUEST)
m1 = self.app.make('MockMail')
m2 = self.app.make('MockMail')
self.assertNotEqual(id(m1), id(m2))
def test_app_makes_singleton_instance(self):
self.app.bind('Request', REQUEST)
self.app.singleton('MockMail', MockMail)
m1 = self.app.make('MockMail')
m2 = self.app.make('MockMail')
self.assertEqual(id(m1), id(m2))
self.assertEqual(id(m1.request), id(m2.request))
m1.request.test = 'test'
self.assertEqual(m2.request.test, 'test')
def test_can_set_container_hook(self):
self.app.on_bind('Request', self._func_on_bind)
self.app.bind('Request', REQUEST)
self.assertEqual(self.app.make('Request').path, '/test/on/bind')
def _func_on_bind(self, request, container):
request.path = '/test/on/bind'
def test_can_set_container_hook_with_obj_binding(self):
self.app.on_bind(Request, self._func_on_bind_with_obj)
self.app.bind('Request', REQUEST)
self.assertEqual(self.app.make('Request').path, '/test/on/bind/obj')
def _func_on_bind_with_obj(self, request, container):
request.path = '/test/on/bind/obj'
def test_can_fire_container_hook_on_make(self):
self.app.on_make(Request, self._func_on_make)
self.app.bind('Request', REQUEST)
self.assertEqual(self.app.make('Request').path, '/test/on/make')
self.assertEqual(self.app.make('Request').path, '/test/on/make')
def _func_on_make(self, request, container):
request.path = '/test/on/make'
def test_can_fire_hook_on_resolve(self):
self.app.on_resolve(Request, self._func_on_resolve)
self.app.bind('Request', REQUEST)
self.assertEqual(self.app.resolve(self._resolve_request).path, '/on/resolve')
self.assertEqual(self.app.resolve(self._resolve_request).path, '/on/resolve')
def test_can_fire_hook_on_resolve_class(self):
self.app.on_resolve(Request, self._func_on_resolve_class)
self.app.bind('Request', REQUEST)
self.assertEqual(self.app.resolve(self._resolve_reques_class).path, '/on/resolve/class')
self.assertEqual(self.app.resolve(self._resolve_reques_class).path, '/on/resolve/class')
def test_can_resolve_parameter_with_keyword_argument_setting(self):
self.app.bind('Request', REQUEST)
self.app.resolve_parameters = True
self.assertEqual(self.app.resolve(self._resolve_parameter), REQUEST)
self.assertEqual(self.app.resolve(self._resolve_parameter), REQUEST)
def _func_on_resolve(self, request, container):
request.path = '/on/resolve'
def _func_on_resolve_class(self, request, container):
request.path = '/on/resolve/class'
def _resolve_request(self, request: Request):
return request
def _resolve_parameter(self, Request):
return Request
def _resolve_reques_class(self, request: Request):
return request
class TestMailManager(unittest.TestCase):
def setUp(self):
self.app = App()
self.app = self.app.bind('Container', self.app)
self.app.bind('Test', object)
self.app.bind('MailSmtpDriver', object)
self.app.bind('View', View(self.app).render)
self.app.bind('ViewClass', View(self.app))
def test_mail_manager_loads_container(self):
mailManager = MailManager(self.app)
self.assertTrue(mailManager.load_container(self.app))
def test_mail_manager_resolves_from_contract(self):
self.app.singleton('MailManager', MailManager)
self.assertEqual(self.app.resolve(self._test_resolve),
self.app.make('MailManager'))
def _test_resolve(self, mail: MailManagerContract):
return mail
def test_creates_driver(self):
mailManager = MailManager(self.app)
self.assertIsInstance(mailManager.manage_driver, object)
def test_does_not_create_driver_with_initilization_container(self):
mailManager = MailManager(self.app)
self.assertEqual(mailManager.manage_driver, None)
def test_does_not_raise_drivernotfound_exception(self):
MailManager(self.app)
def test_manager_sets_driver(self):
self.app.bind('MailMailtrapDriver', Mailgun)
MailManager(self.app).driver('mailtrap')
def test_manager_sets_driver_throws_driver_not_found_exception(self):
with self.assertRaises(DriverNotFound):
MailManager(self.app).driver('mailtrap')
def test_drivers_are_resolvable_by_container(self):
self.app.bind('MailSmtpDriver', MailDriver)
self.assertIsInstance(MailManager(self.app).driver('smtp'), MailDriver)
def test_driver_loads_template(self):
self.app.bind('MailSmtpDriver', MailDriver)
driver = MailManager(self.app).driver('smtp')
self.assertEqual(
driver.template('test', {
'test': 'test'
}).message_body, 'test')
def test_send_mail(self):
self.app.bind('MailSmtpDriver', MailDriver)
self.assertTrue(
MailManager(self.app).driver('smtp').to('*****@*****.**'))
def test_send_mail_with_from(self):
self.app.bind('MailSmtpDriver', MailDriver)
self.assertEqual(
MailManager(
self.app).driver('smtp').to('*****@*****.**').send_from(
'*****@*****.**').from_address,
'*****@*****.**')
def test_send_mail_sends(self):
if env('RUN_MAIL'):
self.app.bind('MailSmtpDriver', MailDriver)
self.assertTrue(
MailManager(self.app).driver('smtp').to(
'*****@*****.**').send('hi'))
def test_send_mail_sends_with_queue(self):
if env('RUN_MAIL'):
self.app.bind('MailSmtpDriver', MailDriver)
self.assertEqual(
MailManager(self.app).driver('smtp').to(
'*****@*****.**').queue().send('hi'), None)
def test_send_mail_with_subject(self):
self.app.bind('MailSmtpDriver', MailDriver)
self.assertEqual(
MailManager(self.app).driver('smtp').to('').subject(
'test').message_subject, 'test')
def test_send_mail_with_callable(self):
self.app.bind('MailSmtpDriver', MailDriver)
user = User
user.email = '*****@*****.**'
self.assertTrue(MailManager(self.app).driver('smtp').to(User))
def test_switch_mail_manager(self):
self.app.bind('MailSmtpDriver', MailDriver)
self.app.bind('MailTestDriver', Mailgun)
mail_driver = MailManager(self.app).driver('smtp')
self.assertIsInstance(mail_driver.driver('test'), Mailgun)
def test_mail_helper_method_resolves_a_driver(self):
self.assertIsInstance(mail_helper(), MailContract)
container.bind('Container', container)
container.bind('Providers', [])
container.bind('WSGIProviders', [])
"""Bind all service providers
Let's register everything into the Service Container. Once everything is
in the container we can run through all the boot methods. For reasons
some providers don't need to execute with every request and should
only run once when the server is started. Providers will be ran
once if the wsgi attribute on a provider is False.
"""
for provider in config('providers.providers'):
located_provider = provider()
located_provider.load_app(container).register()
if located_provider.wsgi:
container.make('WSGIProviders').append(located_provider)
else:
container.make('Providers').append(located_provider)
for provider in container.make('Providers'):
container.resolve(provider.boot)
"""Get the application from the container
Some providers may change the WSGI Server like wrapping the WSGI server
in a Whitenoise container for an example. Let's get a WSGI instance
from the container and pass it to the application variable. This
will allow WSGI servers to pick it up from the command line
"""
application = container.make('WSGI')
class TestContainer(unittest.TestCase):
def setUp(self):
self.app = App()
self.app.bind('Request', Request(None))
self.app.bind('MockObject', MockObject)
self.app.bind('GetObject', GetObject)
self.app.bind('Container', self.app)
def test_container_gets_direct_class(self):
self.assertIsInstance(self.app.make('Request'), Request)
def test_container_resolving_annotation(self):
self.assertIsInstance(self.app.resolve(self._function_test_annotation), MockObject)
def _function_test_annotation(self, mock: MockObject):
return mock
def test_container_resolving_instance_of_object(self):
self.app = App()
self.app.bind('Get', GetObject)
self.assertIsInstance(self.app.resolve(self._function_test_annotation), GetObject)
def test_container_resolving_similiar_objects(self):
self.app.bind('GetAnotherObject', GetAnotherObject)
obj = self.app.resolve(self._function_test_find_method_on_similiar_objects)
self.assertEqual(obj[0], 2)
self.assertEqual(obj[1], 1)
def _function_test_find_method_on_similiar_objects(self, user: GetAnotherObject, country: GetObject):
return [user.find(), country.find()]
def test_raises_error_when_getting_instances_of_classes(self):
with self.assertRaises(ContainerError):
self.assertTrue(self.app.resolve(self._function_test_find_method_on_similiar_objects))
def _function_test_double_annotations(self, mock: MockObject, request: Request):
return {'mock': mock, 'request': request}
def test_container_resolving_multiple_annotations(self):
self.assertIsInstance(self.app.resolve(self._function_test_double_annotations)['mock'], MockObject)
self.assertIsInstance(self.app.resolve(self._function_test_double_annotations)['request'], Request)
def test_container_contract_returns_upload_disk_driver(self):
self.app.bind('UploadDiskDriver', UploadDiskDriver)
self.assertIsInstance(self.app.resolve(self._function_test_contracts), UploadDiskDriver)
def _function_test_contracts(self, upload: UploadContract):
return upload
def _function_not_in_container(self, NotIn):
return NotIn
def test_container_raises_value_error(self):
with self.assertRaises(ContainerError):
self.assertTrue(self.app.resolve(self._function_not_in_container))
def test_container_collects_correct_objects(self):
self.app.bind('ExceptionHook', object)
self.app.bind('SentryExceptionHook', object)
self.app.bind('ExceptionHandler', object)
self.assertEqual(self.app.collect('*ExceptionHook'), {'ExceptionHook': object, 'SentryExceptionHook': object})
self.assertEqual(self.app.collect('Exception*'), {'ExceptionHook': object, 'ExceptionHandler': object})
self.assertEqual(self.app.collect('Sentry*Hook'), {'SentryExceptionHook': object})
with self.assertRaises(AttributeError):
self.app.collect('Sentry')
def test_container_collects_correct_subclasses_of_classes(self):
self.app.bind('GetAnotherObject', GetAnotherObject)
objects = self.app.collect(MockObject)
self.assertIn('GetAnotherObject', objects)
self.assertIn('GetObject', objects)
def test_container_collects_correct_subclasses_of_objects(self):
self.app.bind('GetAnotherObject', GetAnotherObject())
objects = self.app.collect(MockObject)
self.assertIn('GetAnotherObject', objects)
self.assertIn('GetObject', objects)
def test_container_makes_from_class(self):
self.assertIsInstance(self.app.make(Request), Request)
def test_container_can_bind_and_make_from_class_key(self):
self.app.bind(MakeObject, MakeObject)
self.assertIsInstance(self.app.make(MakeObject), MakeObject)
def test_container_makes_from_base_class(self):
del self.app.providers['MockObject']
self.assertIsInstance(self.app.make(MockObject), GetObject)
def test_container_has_obj(self):
assert self.app.has('Request')
assert self.app.has(Request)
def test_container_makes_from_contract(self):
self.app.bind('UploadDriver', UploadDiskDriver)
self.assertIsInstance(self.app.make(UploadContract), UploadDiskDriver)
def test_strict_container_raises_exception(self):
self.app = App(strict=True)
self.app.bind('Request', object)
with self.assertRaises(StrictContainerException):
self.app.bind('Request', object)
def test_override_container_does_not_override(self):
self.app = App(override=False)
self.app.bind('Request', 'test')
self.app.bind('Request', 'override')
self.assertEqual(self.app.make('Request'), 'test')
def test_app_simple_bind(self):
app = App()
app.simple(Request)
self.assertEqual(app.providers, {Request: Request})
def test_app_simple_bind_init(self):
app = App()
req = Request()
app.simple(req)
self.assertEqual(app.providers, {Request: req})
def test_app_make_after_simple_bind(self):
app = App()
req = Request()
app.simple(req)
self.assertEqual(app.make(Request), req)
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_resolves_variables(self, var1, request: Request, var2):
return [var1, request, var2]
def test_can_substitute(self):
app = App()
app.swap(SubstituteThis, self._substitute)
self.assertEqual(app.resolve(self._test_substitute), 'test')
def test_can_substitute_with_object(self):
app = App()
app.swap(SubstituteThis, MakeObject())
self.assertIsInstance(app.resolve(self._test_substitute), MakeObject)
def test_instantiates_obj(self):
app = App()
app.bind('MockSelf', MockSelfObject)
self.assertEqual(app.resolve(self._test_self_object).id, 1)
def test_can_use_in_keyword(self):
app = App()
app.bind('test', 'value')
self.assertIn('test', app)
def test_can_substitute_with_make_object(self):
app = App()
app.swap(SubstituteThis, MakeObject())
self.assertIsInstance(app.make(SubstituteThis), MakeObject)
def _substitute(self, _, __):
return 'test'
def _test_substitute(self, test: SubstituteThis):
return test
def _test_self_object(self, obj: MockSelfObject):
return obj
def test_instantiates_obj(self):
app = App()
app.bind('MockSelf', MockSelfObject)
self.assertEqual(app.resolve(self._test_self_object).id, 1)
def test_can_substitute_with_object(self):
app = App()
app.swap(SubstituteThis, MakeObject())
self.assertIsInstance(app.resolve(self._test_substitute), MakeObject)
def test_can_substitute(self):
app = App()
app.swap(SubstituteThis, self._substitute)
self.assertEqual(app.resolve(self._test_substitute), 'test')
