def test_service_provider_supports_set_by_name():
provider = Services()
singleton_cat = Cat('Celine')
provider.set('my_cat', singleton_cat)
cat = provider.get('my_cat')
assert cat is not None
assert cat.name == "Celine"
def test_request_binding():
def handler(request):
...
binders = get_binders(Route(b"/", handler), Services())
assert isinstance(binders[0], RequestBinder)
def test_parameters_get_binders_list_types_default_from_query_required():
def handler(a: List[str]):
...
binders = get_binders(Route(b"/", handler), Services())
assert all(isinstance(binder, QueryBinder) for binder in binders)
assert all(binder.required for binder in binders)
def test_services_binding():
app_services = Services()
def handler(services):
assert services is app_services
binders = get_binders(Route(b"/", handler), app_services)
assert isinstance(binders[0], ExactBinder)
async def test_services_from_normalization():
app_services = Services()
def handler(services):
assert services is app_services
return None
method = normalize_handler(Route(b"/", handler), app_services)
await method(None)
def test_application_use_templates_with_services():
app = Application(services=Services())
use_templates(app,
loader=PackageLoader("tests.testapp", "templates"),
enable_async=False)
assert isinstance(app.services, Services)
assert app.services["jinja_environment"] is not None
def test_identity_binder_by_param_type(annotation_type):
async def handler(param):
...
handler.__annotations__["param"] = annotation_type
binders = get_binders(Route(b"/", handler), Services())
assert isinstance(binders[0], IdentityBinder)
def test_parameters_get_binders_list_types_default_from_query_optional():
def handler(a: Optional[List[str]]):
...
binders = get_binders(Route(b"/", handler), Services())
assert all(isinstance(binder, QueryBinder) for binder in binders)
assert all(binder.required is False for binder in binders)
assert binders[0].parameter_name == "a"
assert binders[0].expected_type == List[str]
def test_parameters_get_binders_default_query():
def handler(a, b, c):
...
binders = get_binders(Route(b"/", handler), Services())
assert all(isinstance(binder, QueryBinder) for binder in binders)
assert binders[0].parameter_name == "a"
assert binders[1].parameter_name == "b"
assert binders[2].parameter_name == "c"
def test_service_provider_supports_set_simple_values():
provider = Services()
provider['one'] = 10
provider['two'] = 12
provider['three'] = 16
assert provider['one'] == 10
assert provider['two'] == 12
assert provider['three'] == 16
def test_parameters_get_binders_from_route():
def handler(a, b, c):
...
binders = get_binders(Route(b"/:a/:b/:c", handler), Services())
assert all(isinstance(binder, RouteBinder) for binder in binders)
assert binders[0].parameter_name == "a"
assert binders[1].parameter_name == "b"
assert binders[2].parameter_name == "c"
def test_parameters_get_binders_from_body_optional():
def handler(a: Optional[Cat]):
...
binders = get_binders(Route(b"/", handler), Services())
assert len(binders) == 1
binder = binders[0]
assert isinstance(binder, JSONBinder)
assert binder.expected_type is Cat
assert binder.required is False
def test_service_provider_supports_set_and_get_item_by_name():
provider = Services()
singleton_cat = Cat('Celine')
provider['my_cat'] = singleton_cat
cat = provider['my_cat']
assert cat is not None
assert cat.name == "Celine"
def test_does_not_throw_for_forward_ref():
def handler(a: "Cat"):
...
get_binders(Route(b"/", handler), Services())
def handler(a: List["str"]):
...
get_binders(Route(b"/", handler), Services())
def handler(a: Optional[List["Cat"]]):
...
get_binders(Route(b"/", handler), Services())
def handler(a: FromQuery["str"]):
...
get_binders(Route(b"/", handler), Services())
def test_parameters_get_binders_from_body():
def handler(a: Cat):
...
binders = get_binders(Route(b"/", handler), Services())
assert len(binders) == 1
binder = binders[0]
assert isinstance(binder, JsonBinder)
assert binder.expected_type is Cat
assert binder.required is True
def test_from_query_optional_list_type():
def handler(a: FromQuery[Optional[List[str]]]):
...
binders = get_binders(Route(b"/", handler), Services())
binder = binders[0]
assert isinstance(binder, QueryBinder)
assert binder.expected_type is List[str]
assert binder.required is False
assert binder.parameter_name == "a"
def test_from_query_optional_type_with_union():
def handler(a: FromQuery[Union[None, str]]):
...
binders = get_binders(Route(b"/", handler), Services())
binder = binders[0]
assert isinstance(binder, QueryBinder)
assert binder.expected_type is str
assert binder.required is False
assert binder.parameter_name == "a"
def test_from_query_unspecified_type():
def handler(a: FromQuery):
...
binders = get_binders(Route(b"/", handler), Services())
binder = binders[0]
assert isinstance(binder, QueryBinder)
assert binder.expected_type is List[str]
assert binder.required is True
assert binder.parameter_name == "a"
def test_from_header_specific_name():
class FromExampleHeader(FromHeader[str]):
name = "example"
def handler(a: FromExampleHeader):
...
binders = get_binders(Route(b"/", handler), Services())
assert isinstance(binders[0], HeaderBinder)
assert binders[0].expected_type is str
assert binders[0].parameter_name == "example"
def test_from_header_accept_language_example():
class AcceptLanguageHeader(FromHeader[str]):
name = "accept-language"
def handler(a: AcceptLanguageHeader):
...
binders = get_binders(Route(b"/", handler), Services())
assert isinstance(binders[0], HeaderBinder)
assert binders[0].expected_type is str
assert binders[0].parameter_name == "accept-language"
def test_services_set_throws_if_service_is_already_defined():
services = Services()
services.set('example', {})
with raises(OverridingServiceException):
services.set('example', [])
def test_parameters_get_binders_simple_types_default_from_query():
def handler(a: str, b: int, c: bool):
...
binders = get_binders(Route(b"/", handler), Services())
assert all(isinstance(binder, QueryBinder) for binder in binders)
assert binders[0].parameter_name == "a"
assert binders[0].expected_type == str
assert binders[1].parameter_name == "b"
assert binders[1].expected_type == int
assert binders[2].parameter_name == "c"
assert binders[2].expected_type == bool
def test_parameters_get_binders_sequence_types_default_from_query():
def handler(a: Sequence[str], b: Sequence[int], c: Sequence[bool]):
...
binders = get_binders(Route(b"/", handler), Services())
assert all(isinstance(binder, QueryBinder) for binder in binders)
assert binders[0].parameter_name == "a"
assert binders[0].expected_type == Sequence[str]
assert binders[1].parameter_name == "b"
assert binders[1].expected_type == Sequence[int]
assert binders[2].parameter_name == "c"
assert binders[2].expected_type == Sequence[bool]
def test_raises_for_unsupported_signature():
app_services = Services()
def handler(services, *args):
assert services is app_services
return services
def handler2(services, **kwargs):
assert services is app_services
return services
def handler3(services, *, key_only):
assert services is app_services
return services
with pytest.raises(UnsupportedSignatureError):
normalize_handler(Route(b"/", handler), Services())
with pytest.raises(UnsupportedSignatureError):
normalize_handler(Route(b"/", handler2), Services())
with pytest.raises(UnsupportedSignatureError):
normalize_handler(Route(b"/", handler3), Services())
def test_from_query_specific_name():
class FromExampleQuery(FromQuery[str]):
name = "example"
def handler(a: FromExampleQuery):
...
binders = get_binders(Route(b"/", handler), Services())
binder = binders[0]
assert isinstance(binder, QueryBinder)
assert binder.expected_type is str
assert binder.required is True
assert binder.parameter_name == "example"
async def test_application_raises_for_controllers_for_invalid_services():
app = FakeApplication(services=Services())
app.controllers_router = RoutesRegistry()
get = app.controllers_router.get
class Home(Controller):
def greet(self):
return "Hello World"
@get()
async def index(self, request: Request):
assert isinstance(self, Home)
return text(self.greet())
with pytest.raises(RequiresServiceContainerError):
app.setup_controllers()
def __init__(self,
router: Optional[Router] = None,
middlewares: Optional[List[Callable]] = None,
resources: Optional[Resources] = None,
services: Optional[Services] = None,
debug: bool = False,
show_error_details: bool = False,
auto_reload: bool = True):
if router is None:
router = Router()
if services is None:
services = Services()
super().__init__(get_show_error_details(debug or show_error_details),
router, services)
if middlewares is None:
middlewares = []
if resources is None:
resources = Resources(get_resource_file_content('error.html'))
self.debug = debug
self.auto_reload = auto_reload
self.running = False
self.middlewares = middlewares
self.processes = []
self.access_logger = None
self.logger = None
self._default_headers = None
self._use_sync_logging = False
self._middlewares_configured = False
self.resources = resources
self._serve_files = None
self._authentication_strategy = None # type: Optional[AuthenticationStrategy]
self._authorization_strategy = None # type: Optional[AuthorizationStrategy]
self.on_start = ApplicationEvent(self)
self.on_stop = ApplicationEvent(self)
self.started = False
def test_middleware_not_normalized_if_signature_matches_expected_signature():
async def middleware(request, handler):
return await handler(request)
normalized = normalize_middleware(middleware, Services())
assert normalized is middleware
async def test_middleware_normalization_raises_for_sync_function():
def faulty_middleware(request, handler):
pass
with pytest.raises(ValueError):
normalize_middleware(faulty_middleware, Services()) # type: ignore
def test_raises_for_unsupported_union():
def handler(a: FromRoute[Union[str, int]]):
...
with raises(NormalizationError):
get_binders(Route(b"/:b", handler), Services())