Repository: mtag-dev/squall (language: python)

Issue:
Move Param, Query, etc. validators from Dependency scope
The following features block the switching of the dependency injection subsystem.
- Cookie
- Header
- Param
- Query
- Form

 Should be reworked as dedicated code without dependencies


Discussion / hints:

Fix patch:
diff --git a/.github/actions/comment-docs-preview-in-pr/app/main.py b/.github/actions/comment-docs-preview-in-pr/app/main.py
index 3b10e0e..ced12ac 100644
--- a/.github/actions/comment-docs-preview-in-pr/app/main.py
+++ b/.github/actions/comment-docs-preview-in-pr/app/main.py
@@ -55,7 +55,7 @@ class PartialGithubEvent(BaseModel):
     github_headers = {
         "Authorization": f"token {settings.input_token.get_secret_value()}"
     }
-    url = f"{github_api}/repos/{settings.github_repository}/issues/{use_pr.number}/comments"
+    url = f"{github_api}/repos/{settings.github_repository}/issues/{use_pr.numeric}/comments"
     logging.info(f"Using comments URL: {url}")
     response = httpx.post(
         url,
diff --git a/.github/actions/notify-translations/app/main.py b/.github/actions/notify-translations/app/main.py
index 7d6c1a4..1ebddc4 100644
--- a/.github/actions/notify-translations/app/main.py
+++ b/.github/actions/notify-translations/app/main.py
@@ -50,18 +50,18 @@ class PartialGitHubEvent(BaseModel):
     sleep_time = random.random() * 10  # random number between 0 and 10 seconds
     pr = repo.get_pull(github_event.pull_request.number)
     logging.debug(
-        f"Processing PR: {pr.number}, with anti-race condition sleep time: {sleep_time}"
+        f"Processing PR: {pr.numeric}, with anti-race condition sleep time: {sleep_time}"
     )
     if pr.state == "open":
-        logging.debug(f"PR is open: {pr.number}")
+        logging.debug(f"PR is open: {pr.numeric}")
         label_strs = set([label.name for label in pr.get_labels()])
         if lang_all_label in label_strs and awaiting_label in label_strs:
             logging.info(
-                f"This PR seems to be a language translation and awaiting reviews: {pr.number}"
+                f"This PR seems to be a language translation and awaiting reviews: {pr.numeric}"
             )
             if approved_label in label_strs:
                 message = (
-                    f"It seems this PR already has the approved label: {pr.number}"
+                    f"It seems this PR already has the approved label: {pr.numeric}"
                 )
                 logging.error(message)
                 raise RuntimeError(message)
@@ -76,29 +76,29 @@ class PartialGitHubEvent(BaseModel):
                         f"Found a translation issue for language: {lang} in issue: {num}"
                     )
                     issue = repo.get_issue(num)
-                    message = f"Good news everyone! 😉 There's a new translation PR to be reviewed: #{pr.number} 🎉"
+                    message = f"Good news everyone! 😉 There's a new translation PR to be reviewed: #{pr.numeric} 🎉"
                     already_notified = False
                     time.sleep(sleep_time)
                     logging.info(
                         f"Sleeping for {sleep_time} seconds to avoid race conditions and multiple comments"
                     )
                     logging.info(
-                        f"Checking current comments in issue: {num} to see if already notified about this PR: {pr.number}"
+                        f"Checking current comments in issue: {num} to see if already notified about this PR: {pr.numeric}"
                     )
                     for comment in issue.get_comments():
                         if message in comment.body:
                             already_notified = True
                     if not already_notified:
                         logging.info(
-                            f"Writing comment in issue: {num} about PR: {pr.number}"
+                            f"Writing comment in issue: {num} about PR: {pr.numeric}"
                         )
                         issue.create_comment(message)
                     else:
                         logging.info(
-                            f"Issue: {num} was already notified of PR: {pr.number}"
+                            f"Issue: {num} was already notified of PR: {pr.numeric}"
                         )
     else:
         logging.info(
-            f"Changing labels in a closed PR doesn't trigger comments, PR: {pr.number}"
+            f"Changing labels in a closed PR doesn't trigger comments, PR: {pr.numeric}"
         )
     logging.info("Finished")
diff --git a/.github/actions/people/app/main.py b/.github/actions/people/app/main.py
index 6ce3f22..22cd61e 100644
--- a/.github/actions/people/app/main.py
+++ b/.github/actions/people/app/main.py
@@ -525,5 +525,5 @@ def get_top_users(
     subprocess.run(["git", "push", "origin", branch_name], check=True)
     logging.info("Creating PR")
     pr = repo.create_pull(title=message, body=message, base="master", head=branch_name)
-    logging.info(f"Created PR: {pr.number}")
+    logging.info(f"Created PR: {pr.numeric}")
     logging.info("Finished")
diff --git a/.github/actions/watch-previews/app/main.py b/.github/actions/watch-previews/app/main.py
index 0fe8ea3..9a35a8e 100644
--- a/.github/actions/watch-previews/app/main.py
+++ b/.github/actions/watch-previews/app/main.py
@@ -57,7 +57,7 @@ def get_message(commit: str) -> str:
     artifacts_response = ArtifactResponse.parse_obj(data)
     for pr in prs:
         logging.info("-----")
-        logging.info(f"Processing PR #{pr.number}: {pr.title}")
+        logging.info(f"Processing PR #{pr.numeric}: {pr.title}")
         pr_comments = list(pr.get_issue_comments())
         pr_commits = list(pr.get_commits())
         last_commit = pr_commits[0]
@@ -89,7 +89,7 @@ def get_message(commit: str) -> str:
                     json={
                         "ref": "master",
                         "inputs": {
-                            "pr": f"{pr.number}",
+                            "pr": f"{pr.numeric}",
                             "name": artifact_name,
                             "commit": commit,
                         },
diff --git a/docs/en/docs/advanced/custom-request-and-route.md b/docs/en/docs/advanced/custom-request-and-route.md
index f9a8c54..53e13d7 100644
--- a/docs/en/docs/advanced/custom-request-and-route.md
+++ b/docs/en/docs/advanced/custom-request-and-route.md
@@ -76,7 +76,7 @@ But because of our changes in `GzipRequest.body`, the request body will be autom
 ## Accessing the request body in an exception handler
 
 !!! tip
-    To solve this same problem, it's probably a lot easier to use the `body` in a custom handler for `RequestValidationError` ([Handling Errors](../tutorial/handling-errors.md#use-the-requestvalidationerror-body){.internal-link target=_blank}).
+    To solve this same problem, it's probably a lot easier to use the `body` in a custom handler for `RequestPayloadValidationError` ([Handling Errors](../tutorial/handling-errors.md#use-the-requestvalidationerror-body){.internal-link target=_blank}).
 
     But this example is still valid and it shows how to interact with the internal components.
 
diff --git a/docs/en/docs/tutorial/handling-errors.md b/docs/en/docs/tutorial/handling-errors.md
index 1d8487b..ff3403f 100644
--- a/docs/en/docs/tutorial/handling-errors.md
+++ b/docs/en/docs/tutorial/handling-errors.md
@@ -121,11 +121,11 @@ You can override these exception handlers with your own.
 
 ### Override request validation exceptions
 
-When a request contains invalid data, **Squall** internally raises a `RequestValidationError`.
+When a request contains invalid data, **Squall** internally raises a `RequestPayloadValidationError`.
 
 And it also includes a default exception handler for it.
 
-To override it, import the `RequestValidationError` and use it with `@app.exception_handler(RequestValidationError)` to decorate the exception handler.
+To override it, import the `RequestPayloadValidationError` and use it with `@app.exception_handler(RequestPayloadValidationError)` to decorate the exception handler.
 
 The exception handler will receive a `Request` and the exception.
 
@@ -158,12 +158,12 @@ path -> item_id
   value is not a valid integer (type=type_error.integer)
 ```
 
-#### `RequestValidationError` vs `ValidationError`
+#### `RequestPayloadValidationError` vs `ValidationError`
 
 !!! warning
     These are technical details that you might skip if it's not important for you now.
 
-`RequestValidationError` is a sub-class of Pydantic's <a href="https://pydantic-docs.helpmanual.io/#error-handling" class="external-link" target="_blank">`ValidationError`</a>.
+`RequestPayloadValidationError` is a sub-class of Pydantic's <a href="https://pydantic-docs.helpmanual.io/#error-handling" class="external-link" target="_blank">`ValidationError`</a>.
 
 **Squall** uses it so that, if you use a Pydantic model in `response_model`, and your data has an error, you will see the error in your log.
 
@@ -188,9 +188,9 @@ For example, you could want to return a plain text response instead of JSON for
 
     **Squall** provides the same `starlette.responses` as `squall.responses` just as a convenience for you, the developer. But most of the available responses come directly from Starlette.
 
-### Use the `RequestValidationError` body
+### Use the `RequestPayloadValidationError` body
 
-The `RequestValidationError` contains the `body` it received with invalid data.
+The `RequestPayloadValidationError` contains the `body` it received with invalid data.
 
 You could use it while developing your app to log the body and debug it, return it to the user, etc.
 
diff --git a/docs_src/bigger_applications/app/main.py b/docs_src/bigger_applications/app/main.py
index 281a26d..caa5eeb 100644
--- a/docs_src/bigger_applications/app/main.py
+++ b/docs_src/bigger_applications/app/main.py
@@ -1,17 +1,17 @@
-from squall import Depends, Squall
-
-from .dependencies import get_query_token
-from .internal import admin
-from .routers import items, users
-
-app = Squall(dependencies=[Depends(get_query_token)])
-
-
-app.include_router(users.router)
-app.include_router(items.router)
-app.include_router(admin.router)
-
-
-@app.get("/")
-async def root():
-    return {"message": "Hello Bigger Applications!"}
+# from squall import Depends, Squall
+#
+# from .dependencies import get_query_token
+# from .internal import admin
+# from .routers import items, users
+#
+# app = Squall(dependencies=[Depends(get_query_token)])
+#
+#
+# app.include_router(users.router)
+# app.include_router(items.router)
+# app.include_router(admin.router)
+#
+#
+# @app.get("/")
+# async def root():
+#     return {"message": "Hello Bigger Applications!"}
diff --git a/docs_src/custom_request_and_route/tutorial002.py b/docs_src/custom_request_and_route/tutorial002.py
index 7a21acd..d73c006 100644
--- a/docs_src/custom_request_and_route/tutorial002.py
+++ b/docs_src/custom_request_and_route/tutorial002.py
@@ -1,7 +1,7 @@
 from typing import Callable, List
 
 from squall import Body, HTTPException, Request, Response, Squall
-from squall.exceptions import RequestValidationError
+from squall.exceptions import RequestPayloadValidationError
 from squall.routing import APIRoute
 
 
@@ -12,7 +12,7 @@ def get_route_handler(self) -> Callable:
         async def custom_route_handler(request: Request) -> Response:
             try:
                 return await original_route_handler(request)
-            except RequestValidationError as exc:
+            except RequestPayloadValidationError as exc:
                 body = await request.body()
                 detail = {"errors": exc.errors(), "body": body.decode()}
                 raise HTTPException(status_code=422, detail=detail)
diff --git a/docs_src/dependencies/tutorial001.py b/docs_src/dependencies/tutorial001.py
deleted file mode 100644
index 654bb1d..0000000
--- a/docs_src/dependencies/tutorial001.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from typing import Optional
-
-from squall import Depends, Squall
-
-app = Squall()
-
-
-async def common_parameters(q: Optional[str] = None, skip: int = 0, limit: int = 100):
-    return {"q": q, "skip": skip, "limit": limit}
-
-
-@app.get("/items/")
-async def read_items(commons: dict = Depends(common_parameters)):
-    return commons
-
-
-@app.get("/users/")
-async def read_users(commons: dict = Depends(common_parameters)):
-    return commons
diff --git a/docs_src/dependencies/tutorial002.py b/docs_src/dependencies/tutorial002.py
deleted file mode 100644
index 4ff5af1..0000000
--- a/docs_src/dependencies/tutorial002.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from typing import Optional
-
-from squall import Depends, Squall
-
-app = Squall()
-
-
-fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]
-
-
-class CommonQueryParams:
-    def __init__(self, q: Optional[str] = None, skip: int = 0, limit: int = 100):
-        self.q = q
-        self.skip = skip
-        self.limit = limit
-
-
-@app.get("/items/")
-async def read_items(commons: CommonQueryParams = Depends(CommonQueryParams)):
-    response = {}
-    if commons.q:
-        response.update({"q": commons.q})
-    items = fake_items_db[commons.skip : commons.skip + commons.limit]
-    response.update({"items": items})
-    return response
diff --git a/docs_src/dependencies/tutorial003.py b/docs_src/dependencies/tutorial003.py
deleted file mode 100644
index e974150..0000000
--- a/docs_src/dependencies/tutorial003.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from typing import Optional
-
-from squall import Depends, Squall
-
-app = Squall()
-
-
-fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]
-
-
-class CommonQueryParams:
-    def __init__(self, q: Optional[str] = None, skip: int = 0, limit: int = 100):
-        self.q = q
-        self.skip = skip
-        self.limit = limit
-
-
-@app.get("/items/")
-async def read_items(commons=Depends(CommonQueryParams)):
-    response = {}
-    if commons.q:
-        response.update({"q": commons.q})
-    items = fake_items_db[commons.skip : commons.skip + commons.limit]
-    response.update({"items": items})
-    return response
diff --git a/docs_src/dependencies/tutorial004.py b/docs_src/dependencies/tutorial004.py
deleted file mode 100644
index f2718a0..0000000
--- a/docs_src/dependencies/tutorial004.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from typing import Optional
-
-from squall import Depends, Squall
-
-app = Squall()
-
-
-fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]
-
-
-class CommonQueryParams:
-    def __init__(self, q: Optional[str] = None, skip: int = 0, limit: int = 100):
-        self.q = q
-        self.skip = skip
-        self.limit = limit
-
-
-@app.get("/items/")
-async def read_items(commons: CommonQueryParams = Depends()):
-    response = {}
-    if commons.q:
-        response.update({"q": commons.q})
-    items = fake_items_db[commons.skip : commons.skip + commons.limit]
-    response.update({"items": items})
-    return response
diff --git a/docs_src/dependencies/tutorial005.py b/docs_src/dependencies/tutorial005.py
deleted file mode 100644
index f982ec9..0000000
--- a/docs_src/dependencies/tutorial005.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from typing import Optional
-
-from squall import Cookie, Depends, Squall
-
-app = Squall()
-
-
-def query_extractor(q: Optional[str] = None):
-    return q
-
-
-def query_or_cookie_extractor(
-    q: str = Depends(query_extractor), last_query: Optional[str] = Cookie(None)
-):
-    if not q:
-        return last_query
-    return q
-
-
-@app.get("/items/")
-async def read_query(query_or_default: str = Depends(query_or_cookie_extractor)):
-    return {"q_or_cookie": query_or_default}
diff --git a/docs_src/dependencies/tutorial006.py b/docs_src/dependencies/tutorial006.py
deleted file mode 100644
index d81aa5c..0000000
--- a/docs_src/dependencies/tutorial006.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from squall import Depends, Header, HTTPException, Squall
-
-app = Squall()
-
-
-async def verify_token(x_token: str = Header(...)):
-    if x_token != "fake-super-secret-token":
-        raise HTTPException(status_code=400, detail="X-Token header invalid")
-
-
-async def verify_key(x_key: str = Header(...)):
-    if x_key != "fake-super-secret-key":
-        raise HTTPException(status_code=400, detail="X-Key header invalid")
-    return x_key
-
-
-@app.get("/items/", dependencies=[Depends(verify_token), Depends(verify_key)])
-async def read_items():
-    return [{"item": "Foo"}, {"item": "Bar"}]
diff --git a/docs_src/dependencies/tutorial007.py b/docs_src/dependencies/tutorial007.py
deleted file mode 100644
index 2e4ab47..0000000
--- a/docs_src/dependencies/tutorial007.py
+++ /dev/null
@@ -1,6 +0,0 @@
-async def get_db():
-    db = DBSession()
-    try:
-        yield db
-    finally:
-        db.close()
diff --git a/docs_src/dependencies/tutorial008.py b/docs_src/dependencies/tutorial008.py
deleted file mode 100644
index a34a1cf..0000000
--- a/docs_src/dependencies/tutorial008.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from squall import Depends
-
-
-async def dependency_a():
-    dep_a = generate_dep_a()
-    try:
-        yield dep_a
-    finally:
-        dep_a.close()
-
-
-async def dependency_b(dep_a=Depends(dependency_a)):
-    dep_b = generate_dep_b()
-    try:
-        yield dep_b
-    finally:
-        dep_b.close(dep_a)
-
-
-async def dependency_c(dep_b=Depends(dependency_b)):
-    dep_c = generate_dep_c()
-    try:
-        yield dep_c
-    finally:
-        dep_c.close(dep_b)
diff --git a/docs_src/dependencies/tutorial009.py b/docs_src/dependencies/tutorial009.py
deleted file mode 100644
index a34a1cf..0000000
--- a/docs_src/dependencies/tutorial009.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from squall import Depends
-
-
-async def dependency_a():
-    dep_a = generate_dep_a()
-    try:
-        yield dep_a
-    finally:
-        dep_a.close()
-
-
-async def dependency_b(dep_a=Depends(dependency_a)):
-    dep_b = generate_dep_b()
-    try:
-        yield dep_b
-    finally:
-        dep_b.close(dep_a)
-
-
-async def dependency_c(dep_b=Depends(dependency_b)):
-    dep_c = generate_dep_c()
-    try:
-        yield dep_c
-    finally:
-        dep_c.close(dep_b)
diff --git a/docs_src/dependencies/tutorial010.py b/docs_src/dependencies/tutorial010.py
deleted file mode 100644
index c27f1b1..0000000
--- a/docs_src/dependencies/tutorial010.py
+++ /dev/null
@@ -1,14 +0,0 @@
-class MySuperContextManager:
-    def __init__(self):
-        self.db = DBSession()
-
-    def __enter__(self):
-        return self.db
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.db.close()
-
-
-async def get_db():
-    with MySuperContextManager() as db:
-        yield db
diff --git a/docs_src/dependencies/tutorial011.py b/docs_src/dependencies/tutorial011.py
deleted file mode 100644
index bbf7192..0000000
--- a/docs_src/dependencies/tutorial011.py
+++ /dev/null
@@ -1,21 +0,0 @@
-from squall import Depends, Squall
-
-app = Squall()
-
-
-class FixedContentQueryChecker:
-    def __init__(self, fixed_content: str):
-        self.fixed_content = fixed_content
-
-    def __call__(self, q: str = ""):
-        if q:
-            return self.fixed_content in q
-        return False
-
-
-checker = FixedContentQueryChecker("bar")
-
-
-@app.get("/query-checker/")
-async def read_query_check(fixed_content_included: bool = Depends(checker)):
-    return {"fixed_content_in_query": fixed_content_included}
diff --git a/docs_src/dependencies/tutorial012.py b/docs_src/dependencies/tutorial012.py
deleted file mode 100644
index 24f33ef..0000000
--- a/docs_src/dependencies/tutorial012.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from squall import Depends, Header, HTTPException, Squall
-
-
-async def verify_token(x_token: str = Header(...)):
-    if x_token != "fake-super-secret-token":
-        raise HTTPException(status_code=400, detail="X-Token header invalid")
-
-
-async def verify_key(x_key: str = Header(...)):
-    if x_key != "fake-super-secret-key":
-        raise HTTPException(status_code=400, detail="X-Key header invalid")
-    return x_key
-
-
-app = Squall(dependencies=[Depends(verify_token), Depends(verify_key)])
-
-
-@app.get("/items/")
-async def read_items():
-    return [{"item": "Portal Gun"}, {"item": "Plumbus"}]
-
-
-@app.get("/users/")
-async def read_users():
-    return [{"username": "Rick"}, {"username": "Morty"}]
diff --git a/docs_src/extending_openapi/tutorial001.py b/docs_src/extending_openapi/tutorial001.py
index cac2b31..8fe0fee 100644
--- a/docs_src/extending_openapi/tutorial001.py
+++ b/docs_src/extending_openapi/tutorial001.py
@@ -1,28 +1,28 @@
-from squall import Squall
-from squall.openapi.utils import get_openapi
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items():
-    return [{"name": "Foo"}]
-
-
-def custom_openapi():
-    if app.openapi_schema:
-        return app.openapi_schema
-    openapi_schema = get_openapi(
-        title="Custom title",
-        version="2.5.0",
-        description="This is a very custom OpenAPI schema",
-        routes=app.routes,
-    )
-    openapi_schema.info.logo = {
-        "url": "https://squall.mtag.dev/img/logo-margin/logo-teal.png"
-    }
-    app.openapi_schema = openapi_schema
-    return app.openapi_schema
-
-
-app.openapi = custom_openapi
+# from squall import Squall
+# from squall.openapi.utils import get_openapi
+#
+# app = Squall()
+#
+#
+# @app.get("/items/")
+# async def read_items():
+#     return [{"name": "Foo"}]
+#
+#
+# def custom_openapi():
+#     if app.openapi_schema:
+#         return app.openapi_schema
+#     openapi_schema = get_openapi(
+#         title="Custom title",
+#         version="2.5.0",
+#         description="This is a very custom OpenAPI schema",
+#         routes=app.routes,
+#     )
+#     openapi_schema.info.logo = {
+#         "url": "https://squall.mtag.dev/img/logo-margin/logo-teal.png"
+#     }
+#     app.openapi_schema = openapi_schema
+#     return app.openapi_schema
+#
+#
+# app.openapi = custom_openapi
diff --git a/docs_src/handling_errors/tutorial004.py b/docs_src/handling_errors/tutorial004.py
index df5e7ea..2055be0 100644
--- a/docs_src/handling_errors/tutorial004.py
+++ b/docs_src/handling_errors/tutorial004.py
@@ -1,5 +1,5 @@
 from squall import HTTPException, Squall
-from squall.exceptions import RequestValidationError
+from squall.exceptions import RequestPayloadValidationError
 from squall.responses import PlainTextResponse
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
@@ -11,7 +11,7 @@ async def http_exception_handler(request, exc):
     return PlainTextResponse(str(exc.detail), status_code=exc.status_code)
 
 
-@app.exception_handler(RequestValidationError)
+@app.exception_handler(RequestPayloadValidationError)
 async def validation_exception_handler(request, exc):
     return PlainTextResponse(str(exc), status_code=400)
 
diff --git a/docs_src/handling_errors/tutorial005.py b/docs_src/handling_errors/tutorial005.py
index 27052b7..5656a55 100644
--- a/docs_src/handling_errors/tutorial005.py
+++ b/docs_src/handling_errors/tutorial005.py
@@ -1,13 +1,15 @@
 from pydantic import Field, dataclasses
 from squall import Request, Squall, status
-from squall.exceptions import RequestValidationError
+from squall.exceptions import RequestPayloadValidationError
 from squall.responses import JSONResponse
 
 app = Squall()
 
 
-@app.exception_handler(RequestValidationError)
-async def validation_exception_handler(request: Request, exc: RequestValidationError):
+@app.exception_handler(RequestPayloadValidationError)
+async def validation_exception_handler(
+    request: Request, exc: RequestPayloadValidationError
+):
     return JSONResponse(
         status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
         content={"detail": exc.errors(), "body": exc.body},
diff --git a/docs_src/handling_errors/tutorial006.py b/docs_src/handling_errors/tutorial006.py
index 2ec35f2..7074220 100644
--- a/docs_src/handling_errors/tutorial006.py
+++ b/docs_src/handling_errors/tutorial006.py
@@ -1,9 +1,9 @@
 from squall import HTTPException, Squall
 from squall.exception_handlers import (
     http_exception_handler,
-    request_validation_exception_handler,
+    request_payload_validation_exception_handler,
 )
-from squall.exceptions import RequestValidationError
+from squall.exceptions import RequestPayloadValidationError
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
 app = Squall()
@@ -15,10 +15,10 @@ async def custom_http_exception_handler(request, exc):
     return await http_exception_handler(request, exc)
 
 
-@app.exception_handler(RequestValidationError)
+@app.exception_handler(RequestPayloadValidationError)
 async def validation_exception_handler(request, exc):
     print(f"OMG! The client sent invalid data!: {exc}")
-    return await request_validation_exception_handler(request, exc)
+    return await request_payload_validation_exception_handler(request, exc)
 
 
 @app.get("/items/{item_id}")
diff --git a/docs_src/query_params_str_validations/tutorial012.py b/docs_src/query_params_str_validations/tutorial012.py
deleted file mode 100644
index 08a647a..0000000
--- a/docs_src/query_params_str_validations/tutorial012.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from typing import List
-
-from squall import Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(q: List[str] = Query(["foo", "bar"])):
-    query_items = {"q": q}
-    return query_items
diff --git a/docs_src/query_params_str_validations/tutorial013.py b/docs_src/query_params_str_validations/tutorial013.py
deleted file mode 100644
index e6c59de..0000000
--- a/docs_src/query_params_str_validations/tutorial013.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from squall import Query, Squall
-
-app = Squall()
-
-
-@app.get("/items/")
-async def read_items(q: list = Query([])):
-    query_items = {"q": q}
-    return query_items
diff --git a/docs_src/settings/app02/main.py b/docs_src/settings/app02/main.py
index ce07cca..a0f0e28 100644
--- a/docs_src/settings/app02/main.py
+++ b/docs_src/settings/app02/main.py
@@ -1,21 +1,21 @@
-from functools import lru_cache
-
-from squall import Depends, Squall
-
-from .config import Settings
-
-app = Squall()
-
-
-@lru_cache()
-def get_settings():
-    return Settings()
-
-
-@app.get("/info")
-async def info(settings: Settings = Depends(get_settings)):
-    return {
-        "app_name": settings.app_name,
-        "admin_email": settings.admin_email,
-        "items_per_user": settings.items_per_user,
-    }
+# from functools import lru_cache
+#
+# from squall import Depends, Squall
+#
+# from .config import Settings
+#
+# app = Squall()
+#
+#
+# @lru_cache()
+# def get_settings():
+#     return Settings()
+#
+#
+# @app.get("/info")
+# async def info(settings: Settings = Depends(get_settings)):
+#     return {
+#         "app_name": settings.app_name,
+#         "admin_email": settings.admin_email,
+#         "items_per_user": settings.items_per_user,
+#     }
diff --git a/pyproject.toml b/pyproject.toml
index 5124b2a..343b431 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -10,7 +10,6 @@ authors = [
     {name = "Stanislav Dubrovskyi", email = "s.dubrovskyi@cleverdec.com"},
 ]
 maintainers = [
-    {name = "Anton Kuzmenko", email = "hotk@hey.com"},
     {name = "Vitalii Kovalchuk", email = "naviot96@gmail.com"},
 ]
 
diff --git a/squall/__init__.py b/squall/__init__.py
index bd415d3..cf2d060 100644
--- a/squall/__init__.py
+++ b/squall/__init__.py
@@ -8,15 +8,17 @@
 from .background import BackgroundTasks as BackgroundTasks
 from .datastructures import UploadFile as UploadFile
 from .exceptions import HTTPException as HTTPException
+
+# from .param_functions import Depends as Depends
 from .param_functions import Body as Body
 from .param_functions import Cookie as Cookie
-from .param_functions import Depends as Depends
 from .param_functions import File as File
 from .param_functions import Form as Form
 from .param_functions import Header as Header
 from .param_functions import Path as Path
 from .param_functions import Query as Query
-from .param_functions import Security as Security
+
+# from .param_functions import Security as Security
 from .requests import Request as Request
 from .responses import Response as Response
 from .router import Router as Router
diff --git a/squall/applications.py b/squall/applications.py
index 1f5d87e..a8b8d5f 100644
--- a/squall/applications.py
+++ b/squall/applications.py
@@ -1,14 +1,14 @@
 import typing
-from typing import Any, Callable, Dict, List, Optional, Sequence, Type, Union
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Sequence, Type, Union
 
 from squall import router
-from squall.concurrency import AsyncExitStack
 from squall.datastructures import Default
 from squall.exception_handlers import (
     http_exception_handler,
-    request_validation_exception_handler,
+    request_head_validation_exception_handler,
+    request_payload_validation_exception_handler,
 )
-from squall.exceptions import RequestValidationError
+from squall.exceptions import RequestHeadValidationError, RequestPayloadValidationError
 from squall.lifespan import LifespanContext, lifespan
 from squall.logger import logger
 from squall.openapi.docs import (
@@ -17,7 +17,8 @@
     get_swagger_ui_oauth2_redirect_html,
 )
 from squall.openapi.utils import get_openapi
-from squall.params import Depends
+
+# from squall.params import Depends
 from squall.requests import Request
 from squall.responses import HTMLResponse, JSONResponse, Response
 from squall.routing import APIRoute, APIWebSocketRoute
@@ -41,7 +42,6 @@ def __init__(
         openapi_url: Optional[str] = "/openapi.json",
         openapi_tags: Optional[List[Dict[str, Any]]] = None,
         servers: Optional[List[Dict[str, Union[str, Any]]]] = None,
-        dependencies: Optional[Sequence[Depends]] = None,
         default_response_class: Type[Response] = Default(JSONResponse),
         docs_url: Optional[str] = "/docs",
         redoc_url: Optional[str] = "/redoc",
@@ -68,11 +68,11 @@ def __init__(
         self.router: router.RootRouter = router.RootRouter(
             routes=routes,
             default_response_class=default_response_class,
-            dependencies=dependencies,
+            # dependencies=dependencies,
             deprecated=deprecated,
             include_in_schema=include_in_schema,
             responses=responses,
-            dependency_overrides_provider=self,
+            # dependency_overrides_provider=self,
         )
         # Router methods linking for better user experience like having
         # @app.get(...) instead of @app.get(...)
@@ -96,7 +96,10 @@ def __init__(
         )
         self.exception_handlers.setdefault(HTTPException, http_exception_handler)
         self.exception_handlers.setdefault(
-            RequestValidationError, request_validation_exception_handler
+            RequestPayloadValidationError, request_payload_validation_exception_handler
+        )
+        self.exception_handlers.setdefault(
+            RequestHeadValidationError, request_head_validation_exception_handler
         )
 
         self.user_middleware: List[Middleware] = (
@@ -128,7 +131,7 @@ def __init__(
         self.swagger_ui_oauth2_redirect_url = swagger_ui_oauth2_redirect_url
         self.swagger_ui_init_oauth = swagger_ui_init_oauth
         self.extra = extra
-        self.dependency_overrides: Dict[Callable[..., Any], Callable[..., Any]] = {}
+        # self.dependency_overrides: Dict[Callable[..., Any], Callable[..., Any]] = {}
 
         self.openapi_version = "3.0.2"
 
@@ -280,19 +283,17 @@ def decorator(func: ASGIApp) -> ASGIApp:
 
         return decorator
 
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+    def scoped(self, scope: Scope, receive: Receive, send: Send) -> Awaitable[Any]:
+        if scope["type"] == "lifespan":
+            return lifespan(self.lifespan_ctx, scope, receive, send)
+        return self.middleware_stack(scope, receive, send)
+
+    def __call__(self, scope: Scope) -> Callable[..., Awaitable[Any]]:
         """ASGI calls entrypoint."""
         if self.root_path:
             scope["root_path"] = self.root_path
-
         scope["app"] = self
-        if scope["type"] == "lifespan":
-            await lifespan(self.lifespan_ctx, scope, receive, send)
-            return
-
-        async with AsyncExitStack() as stack:
-            scope["squall_astack"] = stack
-            await self.middleware_stack(scope, receive, send)
+        return lambda receive, send: self.scoped(scope, receive, send)
 
     def _build_middleware_stack(self) -> ASGIApp:
         """Build stack for middlewares pipelining"""
@@ -315,6 +316,8 @@ def _build_middleware_stack(self) -> ASGIApp:
             ]
         )
 
+        # middleware = self.user_middleware
+        #
         app = self.router
         for cls, options in reversed(middleware):
             app = cls(app=app, **options)
@@ -338,6 +341,7 @@ def openapi(self) -> Dict[str, Any]:
 
     def _setup(self) -> None:
         """Setups OpenAPI functionality"""
+        # return
         if self.openapi_url:
             urls = (server_data.get("url") for server_data in self.servers)
             server_urls = {url for url in urls if url}
diff --git a/squall/dependencies/models.py b/squall/dependencies/models.py
deleted file mode 100644
index f2b8a05..0000000
--- a/squall/dependencies/models.py
+++ /dev/null
@@ -1,58 +0,0 @@
-from typing import Any, Callable, List, Optional, Sequence
-
-from pydantic.fields import ModelField
-from squall.security.base import SecurityBase
-
-
-class SecurityRequirement:
-    def __init__(
-        self, security_scheme: SecurityBase, scopes: Optional[Sequence[str]] = None
-    ):
-        self.security_scheme = security_scheme
-        self.scopes = scopes
-
-
-class Dependant:
-    def __init__(
-        self,
-        *,
-        path_params: Optional[List[ModelField]] = None,
-        query_params: Optional[List[ModelField]] = None,
-        header_params: Optional[List[ModelField]] = None,
-        cookie_params: Optional[List[ModelField]] = None,
-        body_params: Optional[List[ModelField]] = None,
-        dependencies: Optional[List["Dependant"]] = None,
-        security_schemes: Optional[List[SecurityRequirement]] = None,
-        name: Optional[str] = None,
-        call: Optional[Callable[..., Any]] = None,
-        request_param_name: Optional[str] = None,
-        websocket_param_name: Optional[str] = None,
-        http_connection_param_name: Optional[str] = None,
-        response_param_name: Optional[str] = None,
-        background_tasks_param_name: Optional[str] = None,
-        security_scopes_param_name: Optional[str] = None,
-        security_scopes: Optional[List[str]] = None,
-        use_cache: bool = True,
-        path: Optional[str] = None,
-    ) -> None:
-        self.path_params = path_params or []
-        self.query_params = query_params or []
-        self.header_params = header_params or []
-        self.cookie_params = cookie_params or []
-        self.body_params = body_params or []
-        self.dependencies = dependencies or []
-        self.security_requirements = security_schemes or []
-        self.request_param_name = request_param_name
-        self.websocket_param_name = websocket_param_name
-        self.http_connection_param_name = http_connection_param_name
-        self.response_param_name = response_param_name
-        self.background_tasks_param_name = background_tasks_param_name
-        self.security_scopes = security_scopes
-        self.security_scopes_param_name = security_scopes_param_name
-        self.name = name
-        self.call = call
-        self.use_cache = use_cache
-        # Store the path to be able to re-generate a dependable from it in overrides
-        self.path = path
-        # Save the cache key at creation to optimize performance
-        self.cache_key = (self.call, tuple(sorted(set(self.security_scopes or []))))
diff --git a/squall/dependencies/utils.py b/squall/dependencies/utils.py
deleted file mode 100644
index b0cb305..0000000
--- a/squall/dependencies/utils.py
+++ /dev/null
@@ -1,760 +0,0 @@
-import dataclasses
-import inspect
-from contextlib import contextmanager
-from copy import deepcopy
-from typing import (
-    Any,
-    Callable,
-    Coroutine,
-    Dict,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    Union,
-    cast,
-)
-
-import anyio
-from pydantic import BaseModel, create_model
-from pydantic.error_wrappers import ErrorWrapper
-from pydantic.errors import MissingError
-from pydantic.fields import (
-    SHAPE_LIST,
-    SHAPE_SEQUENCE,
-    SHAPE_SET,
-    SHAPE_SINGLETON,
-    SHAPE_TUPLE,
-    SHAPE_TUPLE_ELLIPSIS,
-    FieldInfo,
-    ModelField,
-    Required,
-)
-from pydantic.schema import get_annotation_from_field_info
-from pydantic.typing import ForwardRef, evaluate_forwardref
-from pydantic.utils import lenient_issubclass
-from squall import params
-from squall.concurrency import (
-    AsyncExitStack,
-    asynccontextmanager,
-    contextmanager_in_threadpool,
-)
-from squall.dependencies.models import Dependant, SecurityRequirement
-from squall.logger import logger
-from squall.requests import Request
-from squall.responses import Response
-from squall.security.base import SecurityBase
-from squall.security.oauth2 import OAuth2, SecurityScopes
-from squall.security.open_id_connect_url import OpenIdConnect
-from squall.utils import create_response_field, get_path_param_names
-from starlette.background import BackgroundTasks
-from starlette.concurrency import run_in_threadpool
-from starlette.datastructures import FormData, Headers, QueryParams, UploadFile
-from starlette.requests import HTTPConnection
-from starlette.websockets import WebSocket
-
-sequence_shapes = {
-    SHAPE_LIST,
-    SHAPE_SET,
-    SHAPE_TUPLE,
-    SHAPE_SEQUENCE,
-    SHAPE_TUPLE_ELLIPSIS,
-}
-sequence_types = (list, set, tuple)
-sequence_shape_to_type = {
-    SHAPE_LIST: list,
-    SHAPE_SET: set,
-    SHAPE_TUPLE: tuple,
-    SHAPE_SEQUENCE: list,
-    SHAPE_TUPLE_ELLIPSIS: list,
-}
-
-
-multipart_not_installed_error = (
-    'Form data requires "python-multipart" to be installed. \n'
-    'You can install "python-multipart" with: \n\n'
-    "pip install python-multipart\n"
-)
-multipart_incorrect_install_error = (
-    'Form data requires "python-multipart" to be installed. '
-    'It seems you installed "multipart" instead. \n'
-    'You can remove "multipart" with: \n\n'
-    "pip uninstall multipart\n\n"
-    'And then install "python-multipart" with: \n\n'
-    "pip install python-multipart\n"
-)
-
-
-def check_file_field(field: ModelField) -> None:
-    field_info = field.field_info
-    if isinstance(field_info, params.Form):
-        try:
-            # __version__ is available in both multiparts, and can be mocked
-            from multipart import __version__  # type: ignore
-
-            assert __version__
-            try:
-                # parse_options_header is only available in the right multipart
-                from multipart.multipart import parse_options_header  # type: ignore
-
-                assert parse_options_header
-            except ImportError:
-                logger.error(multipart_incorrect_install_error)
-                raise RuntimeError(multipart_incorrect_install_error)
-        except ImportError:
-            logger.error(multipart_not_installed_error)
-            raise RuntimeError(multipart_not_installed_error)
-
-
-def get_param_sub_dependant(
-    *, param: inspect.Parameter, path: str, security_scopes: Optional[List[str]] = None
-) -> Dependant:
-    depends: params.Depends = param.default
-    dependency = depends.dependency or param.annotation
-    return get_sub_dependant(
-        depends=depends,
-        dependency=dependency,
-        path=path,
-        name=param.name,
-        security_scopes=security_scopes,
-    )
-
-
-def get_parameterless_sub_dependant(*, depends: params.Depends, path: str) -> Dependant:
-    assert callable(
-        depends.dependency
-    ), "A parameter-less dependency must have a callable dependency"
-    return get_sub_dependant(depends=depends, dependency=depends.dependency, path=path)
-
-
-def get_sub_dependant(
-    *,
-    depends: params.Depends,
-    dependency: Callable[..., Any],
-    path: str,
-    name: Optional[str] = None,
-    security_scopes: Optional[List[str]] = None,
-) -> Dependant:
-    security_requirement = None
-    security_scopes = security_scopes or []
-    if isinstance(depends, params.Security):
-        dependency_scopes = depends.scopes
-        security_scopes.extend(dependency_scopes)
-    if isinstance(dependency, SecurityBase):
-        use_scopes: List[str] = []
-        if isinstance(dependency, (OAuth2, OpenIdConnect)):
-            use_scopes = security_scopes
-        security_requirement = SecurityRequirement(
-            security_scheme=dependency, scopes=use_scopes
-        )
-    sub_dependant = get_dependant(
-        path=path,
-        call=dependency,
-        name=name,
-        security_scopes=security_scopes,
-        use_cache=depends.use_cache,
-    )
-    if security_requirement:
-        sub_dependant.security_requirements.append(security_requirement)
-    sub_dependant.security_scopes = security_scopes
-    return sub_dependant
-
-
-CacheKey = Tuple[Optional[Callable[..., Any]], Tuple[str, ...]]
-
-
-def get_flat_dependant(
-    dependant: Dependant,
-    *,
-    skip_repeats: bool = False,
-    visited: Optional[List[CacheKey]] = None,
-) -> Dependant:
-    if visited is None:
-        visited = []
-    visited.append(dependant.cache_key)
-
-    flat_dependant = Dependant(
-        path_params=dependant.path_params.copy(),
-        query_params=dependant.query_params.copy(),
-        header_params=dependant.header_params.copy(),
-        cookie_params=dependant.cookie_params.copy(),
-        body_params=dependant.body_params.copy(),
-        security_schemes=dependant.security_requirements.copy(),
-        use_cache=dependant.use_cache,
-        path=dependant.path,
-    )
-    for sub_dependant in dependant.dependencies:
-        if skip_repeats and sub_dependant.cache_key in visited:
-            continue
-        flat_sub = get_flat_dependant(
-            sub_dependant, skip_repeats=skip_repeats, visited=visited
-        )
-        flat_dependant.path_params.extend(flat_sub.path_params)
-        flat_dependant.query_params.extend(flat_sub.query_params)
-        flat_dependant.header_params.extend(flat_sub.header_params)
-        flat_dependant.cookie_params.extend(flat_sub.cookie_params)
-        flat_dependant.body_params.extend(flat_sub.body_params)
-        flat_dependant.security_requirements.extend(flat_sub.security_requirements)
-    return flat_dependant
-
-
-def get_flat_params(dependant: Dependant) -> List[ModelField]:
-    flat_dependant = get_flat_dependant(dependant, skip_repeats=True)
-    return (
-        flat_dependant.path_params
-        + flat_dependant.query_params
-        + flat_dependant.header_params
-        + flat_dependant.cookie_params
-    )
-
-
-def is_scalar_field(field: ModelField) -> bool:
-    field_info = field.field_info
-    if not (
-        field.shape == SHAPE_SINGLETON
-        and not lenient_issubclass(field.type_, BaseModel)
-        and not lenient_issubclass(field.type_, sequence_types + (dict,))
-        and not dataclasses.is_dataclass(field.type_)
-        and not isinstance(field_info, params.Body)
-    ):
-        return False
-    if field.sub_fields:
-        if not all(is_scalar_field(f) for f in field.sub_fields):
-            return False
-    return True
-
-
-def is_scalar_sequence_field(field: ModelField) -> bool:
-    if (field.shape in sequence_shapes) and not lenient_issubclass(
-        field.type_, BaseModel
-    ):
-        if field.sub_fields is not None:
-            for sub_field in field.sub_fields:
-                if not is_scalar_field(sub_field):
-                    return False
-        return True
-    return bool(lenient_issubclass(field.type_, sequence_types))
-
-
-def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
-    signature = inspect.signature(call)
-    globalns = getattr(call, "__globals__", {})
-    typed_params = [
-        inspect.Parameter(
-            name=param.name,
-            kind=param.kind,
-            default=param.default,
-            annotation=get_typed_annotation(param, globalns),
-        )
-        for param in signature.parameters.values()
-    ]
-    return inspect.Signature(typed_params)
-
-
-def get_typed_annotation(param: inspect.Parameter, globalns: Dict[str, Any]) -> Any:
-    annotation = param.annotation
-    if isinstance(annotation, str):
-        annotation = ForwardRef(annotation)
-        annotation = evaluate_forwardref(annotation, globalns, globalns)
-    return annotation
-
-
-def get_dependant(
-    *,
-    path: str,
-    call: Callable[..., Any],
-    name: Optional[str] = None,
-    security_scopes: Optional[List[str]] = None,
-    use_cache: bool = True,
-) -> Dependant:
-    path_param_names = get_path_param_names(path)
-    endpoint_signature = get_typed_signature(call)
-    signature_params = endpoint_signature.parameters
-    dependant = Dependant(call=call, name=name, path=path, use_cache=use_cache)
-    for param_name, param in signature_params.items():
-        if isinstance(param.default, params.Depends):
-            sub_dependant = get_param_sub_dependant(
-                param=param, path=path, security_scopes=security_scopes
-            )
-            dependant.dependencies.append(sub_dependant)
-            continue
-        if add_non_field_param_to_dependency(param=param, dependant=dependant):
-            continue
-        param_field = get_param_field(
-            param=param, default_field_info=params.Query, param_name=param_name
-        )
-        if param_name in path_param_names:
-            assert is_scalar_field(
-                field=param_field
-            ), "Path params must be of one of the supported types"
-            ignore_default = not isinstance(param.default, params.Path)
-            param_field = get_param_field(
-                param=param,
-                param_name=param_name,
-                default_field_info=params.Path,
-                force_type=params.ParamTypes.path,
-                ignore_default=ignore_default,
-            )
-            add_param_to_fields(field=param_field, dependant=dependant)
-        elif is_scalar_field(field=param_field):
-            add_param_to_fields(field=param_field, dependant=dependant)
-        elif isinstance(
-            param.default, (params.Query, params.Header)
-        ) and is_scalar_sequence_field(param_field):
-            add_param_to_fields(field=param_field, dependant=dependant)
-        else:
-            field_info = param_field.field_info
-            assert isinstance(
-                field_info, params.Body
-            ), f"Param: {param_field.name} can only be a request body, using Body(...)"
-            dependant.body_params.append(param_field)
-    return dependant
-
-
-def add_non_field_param_to_dependency(
-    *, param: inspect.Parameter, dependant: Dependant
-) -> Optional[bool]:
-    if lenient_issubclass(param.annotation, Request):
-        dependant.request_param_name = param.name
-        return True
-    elif lenient_issubclass(param.annotation, WebSocket):
-        dependant.websocket_param_name = param.name
-        return True
-    elif lenient_issubclass(param.annotation, HTTPConnection):
-        dependant.http_connection_param_name = param.name
-        return True
-    elif lenient_issubclass(param.annotation, Response):
-        dependant.response_param_name = param.name
-        return True
-    elif lenient_issubclass(param.annotation, BackgroundTasks):
-        dependant.background_tasks_param_name = param.name
-        return True
-    elif lenient_issubclass(param.annotation, SecurityScopes):
-        dependant.security_scopes_param_name = param.name
-        return True
-    return None
-
-
-def get_param_field(
-    *,
-    param: inspect.Parameter,
-    param_name: str,
-    default_field_info: Type[params.Param] = params.Param,
-    force_type: Optional[params.ParamTypes] = None,
-    ignore_default: bool = False,
-) -> ModelField:
-    default_value = Required
-    had_schema = False
-    if param.default != param.empty and not ignore_default:
-        default_value = param.default
-    if isinstance(default_value, FieldInfo):
-        had_schema = True
-        field_info = default_value
-        default_value = field_info.default
-        if (
-            isinstance(field_info, params.Param)
-            and getattr(field_info, "in_", None) is None
-        ):
-            field_info.in_ = default_field_info.in_
-        if force_type:
-            field_info.in_ = force_type  # type: ignore
-    else:
-        field_info = default_field_info(default_value)
-    required = default_value == Required
-    annotation: Any = Any
-    if param.annotation != param.empty:
-        annotation = param.annotation
-    annotation = get_annotation_from_field_info(annotation, field_info, param_name)
-    if not field_info.alias and getattr(field_info, "convert_underscores", None):
-        alias = param.name.replace("_", "-")
-    else:
-        alias = field_info.alias or param.name
-    field = create_response_field(
-        name=param.name,
-        type_=annotation,
-        default=None if required else default_value,
-        alias=alias,
-        required=required,
-        field_info=field_info,
-    )
-    field.required = required
-    if not had_schema and not is_scalar_field(field=field):
-        field.field_info = params.Body(field_info.default)
-
-    return field
-
-
-def add_param_to_fields(*, field: ModelField, dependant: Dependant) -> None:
-    field_info = cast(params.Param, field.field_info)
-    if field_info.in_ == params.ParamTypes.path:
-        dependant.path_params.append(field)
-    elif field_info.in_ == params.ParamTypes.query:
-        dependant.query_params.append(field)
-    elif field_info.in_ == params.ParamTypes.header:
-        dependant.header_params.append(field)
-    else:
-        assert (
-            field_info.in_ == params.ParamTypes.cookie
-        ), f"non-body parameters must be in path, query, header or cookie: {field.name}"
-        dependant.cookie_params.append(field)
-
-
-def is_coroutine_callable(call: Callable[..., Any]) -> bool:
-    if inspect.isroutine(call):
-        return inspect.iscoroutinefunction(call)
-    if inspect.isclass(call):
-        return False
-    call = getattr(call, "__call__", None)
-    return inspect.iscoroutinefunction(call)
-
-
-def is_async_gen_callable(call: Callable[..., Any]) -> bool:
-    if inspect.isasyncgenfunction(call):
-        return True
-    call = getattr(call, "__call__", None)
-    return inspect.isasyncgenfunction(call)
-
-
-def is_gen_callable(call: Callable[..., Any]) -> bool:
-    if inspect.isgeneratorfunction(call):
-        return True
-    call = getattr(call, "__call__", None)
-    return inspect.isgeneratorfunction(call)
-
-
-async def solve_generator(
-    *, call: Callable[..., Any], stack: AsyncExitStack, sub_values: Dict[str, Any]
-) -> Any:
-    if is_gen_callable(call):
-        cm = contextmanager_in_threadpool(contextmanager(call)(**sub_values))
-    elif is_async_gen_callable(call):
-        cm = asynccontextmanager(call)(**sub_values)
-    return await stack.enter_async_context(cm)
-
-
-async def solve_dependencies(
-    *,
-    request: Union[Request, WebSocket],
-    dependant: Dependant,
-    body: Optional[Union[Dict[str, Any], FormData]] = None,
-    background_tasks: Optional[BackgroundTasks] = None,
-    response: Optional[Response] = None,
-    dependency_overrides_provider: Optional[Any] = None,
-    dependency_cache: Optional[Dict[Tuple[Callable[..., Any], Tuple[str]], Any]] = None,
-) -> Tuple[
-    Dict[str, Any],
-    List[ErrorWrapper],
-    Optional[BackgroundTasks],
-    Response,
-    Dict[Tuple[Callable[..., Any], Tuple[str]], Any],
-]:
-    values: Dict[str, Any] = {}
-    errors: List[ErrorWrapper] = []
-    response = response or Response(
-        content=None,
-        status_code=None,  # type: ignore
-        headers=None,  # type: ignore # in Starlette
-        media_type=None,  # type: ignore # in Starlette
-        background=None,  # type: ignore # in Starlette
-    )
-    dependency_cache = dependency_cache or {}
-    sub_dependant: Dependant
-    for sub_dependant in dependant.dependencies:
-        sub_dependant.call = cast(Callable[..., Any], sub_dependant.call)
-        sub_dependant.cache_key = cast(
-            Tuple[Callable[..., Any], Tuple[str]], sub_dependant.cache_key
-        )
-        call = sub_dependant.call
-        use_sub_dependant = sub_dependant
-        if (
-            dependency_overrides_provider
-            and dependency_overrides_provider.dependency_overrides
-        ):
-            original_call = sub_dependant.call
-            call = getattr(
-                dependency_overrides_provider, "dependency_overrides", {}
-            ).get(original_call, original_call)
-            use_path: str = sub_dependant.path  # type: ignore
-            use_sub_dependant = get_dependant(
-                path=use_path,
-                call=call,
-                name=sub_dependant.name,
-                security_scopes=sub_dependant.security_scopes,
-            )
-            use_sub_dependant.security_scopes = sub_dependant.security_scopes
-
-        solved_result = await solve_dependencies(
-            request=request,
-            dependant=use_sub_dependant,
-            body=body,
-            background_tasks=background_tasks,
-            response=response,
-            dependency_overrides_provider=dependency_overrides_provider,
-            dependency_cache=dependency_cache,
-        )
-        (
-            sub_values,
-            sub_errors,
-            background_tasks,
-            _,  # the subdependency returns the same response we have
-            sub_dependency_cache,
-        ) = solved_result
-        dependency_cache.update(sub_dependency_cache)
-        if sub_errors:
-            errors.extend(sub_errors)
-            continue
-        if sub_dependant.use_cache and sub_dependant.cache_key in dependency_cache:
-            solved = dependency_cache[sub_dependant.cache_key]
-        elif is_gen_callable(call) or is_async_gen_callable(call):
-            stack = request.scope.get("squall_astack")
-            assert isinstance(stack, AsyncExitStack)
-            solved = await solve_generator(
-                call=call, stack=stack, sub_values=sub_values
-            )
-        elif is_coroutine_callable(call):
-            solved = await call(**sub_values)
-        else:
-            solved = await run_in_threadpool(call, **sub_values)
-        if sub_dependant.name is not None:
-            values[sub_dependant.name] = solved
-        if sub_dependant.cache_key not in dependency_cache:
-            dependency_cache[sub_dependant.cache_key] = solved
-    path_values, path_errors = request_params_to_args(
-        dependant.path_params, request.path_params
-    )
-    query_values, query_errors = request_params_to_args(
-        dependant.query_params, request.query_params
-    )
-    header_values, header_errors = request_params_to_args(
-        dependant.header_params, request.headers
-    )
-    cookie_values, cookie_errors = request_params_to_args(
-        dependant.cookie_params, request.cookies
-    )
-    values.update(path_values)
-    values.update(query_values)
-    values.update(header_values)
-    values.update(cookie_values)
-    errors += path_errors + query_errors + header_errors + cookie_errors
-    if dependant.body_params:
-        (
-            body_values,
-            body_errors,
-        ) = await request_body_to_args(  # body_params checked above
-            required_params=dependant.body_params, received_body=body
-        )
-        values.update(body_values)
-        errors.extend(body_errors)
-    if dependant.http_connection_param_name:
-        values[dependant.http_connection_param_name] = request
-    if dependant.request_param_name and isinstance(request, Request):
-        values[dependant.request_param_name] = request
-    elif dependant.websocket_param_name and isinstance(request, WebSocket):
-        values[dependant.websocket_param_name] = request
-    if dependant.background_tasks_param_name:
-        if background_tasks is None:
-            background_tasks = BackgroundTasks()
-        values[dependant.background_tasks_param_name] = background_tasks
-    if dependant.response_param_name:
-        values[dependant.response_param_name] = response
-    if dependant.security_scopes_param_name:
-        values[dependant.security_scopes_param_name] = SecurityScopes(
-            scopes=dependant.security_scopes
-        )
-    return values, errors, background_tasks, response, dependency_cache
-
-
-def request_params_to_args(
-    required_params: Sequence[ModelField],
-    received_params: Union[Mapping[str, Any], QueryParams, Headers],
-) -> Tuple[Dict[str, Any], List[ErrorWrapper]]:
-    values = {}
-    errors = []
-    for field in required_params:
-        if is_scalar_sequence_field(field) and isinstance(
-            received_params, (QueryParams, Headers)
-        ):
-            value = received_params.getlist(field.alias) or field.default
-        else:
-            value = received_params.get(field.alias)
-        field_info = field.field_info
-        assert isinstance(
-            field_info, params.Param
-        ), "Params must be subclasses of Param"
-        if value is None:
-            if field.required:
-                errors.append(
-                    ErrorWrapper(
-                        MissingError(), loc=(field_info.in_.value, field.alias)
-                    )
-                )
-            else:
-                values[field.name] = deepcopy(field.default)
-            continue
-        v_, errors_ = field.validate(
-            value, values, loc=(field_info.in_.value, field.alias)
-        )
-        if isinstance(errors_, ErrorWrapper):
-            errors.append(errors_)
-        elif isinstance(errors_, list):
-            errors.extend(errors_)
-        else:
-            values[field.name] = v_
-    return values, errors
-
-
-async def request_body_to_args(
-    required_params: List[ModelField],
-    received_body: Optional[Union[Dict[str, Any], FormData]],
-) -> Tuple[Dict[str, Any], List[ErrorWrapper]]:
-    values = {}
-    errors = []
-    if required_params:
-        field = required_params[0]
-        field_info = field.field_info
-        embed = getattr(field_info, "embed", None)
-        field_alias_omitted = len(required_params) == 1 and not embed
-        if field_alias_omitted:
-            received_body = {field.alias: received_body}
-
-        for field in required_params:
-            loc: Tuple[str, ...]
-            if field_alias_omitted:
-                loc = ("body",)
-            else:
-                loc = ("body", field.alias)
-
-            value: Optional[Any] = None
-            if received_body is not None:
-                if (
-                    field.shape in sequence_shapes or field.type_ in sequence_types
-                ) and isinstance(received_body, FormData):
-                    value = received_body.getlist(field.alias)
-                else:
-                    try:
-                        value = received_body.get(field.alias)
-                    except AttributeError:
-                        errors.append(get_missing_field_error(loc))
-                        continue
-            if (
-                value is None
-                or (isinstance(field_info, params.Form) and value == "")
-                or (
-                    isinstance(field_info, params.Form)
-                    and field.shape in sequence_shapes
-                    and len(value) == 0
-                )
-            ):
-                if field.required:
-                    errors.append(get_missing_field_error(loc))
-                else:
-                    values[field.name] = deepcopy(field.default)
-                continue
-            if (
-                isinstance(field_info, params.File)
-                and lenient_issubclass(field.type_, bytes)
-                and isinstance(value, UploadFile)
-            ):
-                value = await value.read()
-            elif (
-                field.shape in sequence_shapes
-                and isinstance(field_info, params.File)
-                and lenient_issubclass(field.type_, bytes)
-                and isinstance(value, sequence_types)
-            ):
-                results: List[Union[bytes, str]] = []
-
-                async def process_fn(
-                    fn: Callable[[], Coroutine[Any, Any, Any]]
-                ) -> None:
-                    result = await fn()
-                    results.append(result)
-
-                async with anyio.create_task_group() as tg:
-                    for sub_value in value:
-                        tg.start_soon(process_fn, sub_value.read)
-                value = sequence_shape_to_type[field.shape](results)
-
-            v_, errors_ = field.validate(value, values, loc=loc)
-
-            if isinstance(errors_, ErrorWrapper):
-                errors.append(errors_)
-            elif isinstance(errors_, list):
-                errors.extend(errors_)
-            else:
-                values[field.name] = v_
-    return values, errors
-
-
-def get_missing_field_error(loc: Tuple[str, ...]) -> ErrorWrapper:
-    return ErrorWrapper(MissingError(), loc=loc)
-
-
-def get_schema_compatible_field(*, field: ModelField) -> ModelField:
-    out_field = field
-    if lenient_issubclass(field.type_, UploadFile):
-        use_type: type = bytes
-        if field.shape in sequence_shapes:
-            use_type = List[bytes]
-        out_field = create_response_field(
-            name=field.name,
-            type_=use_type,
-            class_validators=field.class_validators,
-            model_config=field.model_config,
-            default=field.default,
-            required=field.required,
-            alias=field.alias,
-            field_info=field.field_info,
-        )
-    return out_field
-
-
-def get_body_field(*, dependant: Dependant, name: str) -> Optional[ModelField]:
-    flat_dependant = get_flat_dependant(dependant)
-    if not flat_dependant.body_params:
-        return None
-    first_param = flat_dependant.body_params[0]
-    field_info = first_param.field_info
-    embed = getattr(field_info, "embed", None)
-    body_param_names_set = {param.name for param in flat_dependant.body_params}
-    if len(body_param_names_set) == 1 and not embed:
-        final_field = get_schema_compatible_field(field=first_param)
-        check_file_field(final_field)
-        return final_field
-    # If one field requires to embed, all have to be embedded
-    # in case a sub-dependency is evaluated with a single unique body field
-    # That is combined (embedded) with other body fields
-    for param in flat_dependant.body_params:
-        setattr(param.field_info, "embed", True)
-    model_name = "Body_" + name
-    BodyModel: Type[BaseModel] = create_model(model_name)
-    for f in flat_dependant.body_params:
-        BodyModel.__fields__[f.name] = get_schema_compatible_field(field=f)
-    required = any(True for f in flat_dependant.body_params if f.required)
-
-    BodyFieldInfo_kwargs: Dict[str, Any] = dict(default=None)
-    if any(isinstance(f.field_info, params.File) for f in flat_dependant.body_params):
-        BodyFieldInfo: Type[params.Body] = params.File
-    elif any(isinstance(f.field_info, params.Form) for f in flat_dependant.body_params):
-        BodyFieldInfo = params.Form
-    else:
-        BodyFieldInfo = params.Body
-
-        body_param_media_types = [
-            getattr(f.field_info, "media_type")
-            for f in flat_dependant.body_params
-            if isinstance(f.field_info, params.Body)
-        ]
-        if len(set(body_param_media_types)) == 1:
-            BodyFieldInfo_kwargs["media_type"] = body_param_media_types[0]
-    final_field = create_response_field(
-        name="body",
-        type_=BodyModel,
-        required=required,
-        alias="body",
-        field_info=BodyFieldInfo(**BodyFieldInfo_kwargs),
-    )
-    check_file_field(final_field)
-    return final_field
diff --git a/squall/exception_handlers.py b/squall/exception_handlers.py
index 4828b63..2cfce95 100644
--- a/squall/exception_handlers.py
+++ b/squall/exception_handlers.py
@@ -1,24 +1,33 @@
-from squall.exceptions import RequestValidationError
+from squall.exceptions import RequestHeadValidationError, RequestPayloadValidationError
 from squall.requests import Request
-from squall.responses import JSONResponse
+from squall.responses import JSONResponse, PrettyJSONResponse
 from starlette.exceptions import HTTPException
-from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY
+from starlette.status import HTTP_400_BAD_REQUEST, HTTP_422_UNPROCESSABLE_ENTITY
 
 
 async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
     headers = getattr(exc, "headers", None)
     if headers:
         return JSONResponse(
-            {"detail": exc.detail}, status_code=exc.status_code, headers=headers
+            {"details": exc.detail}, status_code=exc.status_code, headers=headers
         )
     else:
         return JSONResponse({"detail": exc.detail}, status_code=exc.status_code)
 
 
-async def request_validation_exception_handler(
-    request: Request, exc: RequestValidationError
-) -> JSONResponse:
-    return JSONResponse(
+async def request_payload_validation_exception_handler(
+    request: Request, exc: RequestPayloadValidationError
+) -> PrettyJSONResponse:
+    return PrettyJSONResponse(
         status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-        content={"detail": exc.errors()},
+        content={"details": exc.errors()},
+    )
+
+
+async def request_head_validation_exception_handler(
+    request: Request, exc: RequestHeadValidationError
+) -> PrettyJSONResponse:
+    return PrettyJSONResponse(
+        status_code=HTTP_400_BAD_REQUEST,
+        content={"details": exc.errors},
     )
diff --git a/squall/exceptions.py b/squall/exceptions.py
index b18b40f..75f5e18 100644
--- a/squall/exceptions.py
+++ b/squall/exceptions.py
@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional, Sequence, Type
+from typing import Any, Dict, Optional, Sequence, Tuple, Type
 
 from pydantic import BaseModel, ValidationError, create_model
 from pydantic.error_wrappers import ErrorList
@@ -26,12 +26,25 @@ class SquallError(RuntimeError):
     """
 
 
-class RequestValidationError(ValidationError):
+class RequestPayloadValidationError(ValidationError):
     def __init__(self, errors: Sequence[ErrorList], *, body: Any = None) -> None:
         self.body = body
         super().__init__(errors, RequestErrorModel)
 
 
+class RequestHeadValidationError(Exception):
+    def __init__(self, errors: Sequence[Tuple[str, str, str, Any]]) -> None:
+        self.errors = []
+        for source, field, reason, value in errors:
+            error = {
+                "loc": [source, field],
+                "msg": reason,
+            }
+            if value != Ellipsis:
+                error["val"] = value
+            self.errors.append(error)
+
+
 class WebSocketRequestValidationError(ValidationError):
     def __init__(self, errors: Sequence[ErrorList]) -> None:
         super().__init__(errors, WebSocketErrorModel)
diff --git a/squall/openapi/models.py b/squall/openapi/models.py
index 22129cd..41422d1 100644
--- a/squall/openapi/models.py
+++ b/squall/openapi/models.py
@@ -105,9 +105,9 @@ class Schema(BaseModel):
     title: Optional[str] = None
     multipleOf: Optional[float] = None
     maximum: Optional[float] = None
-    exclusiveMaximum: Optional[float] = None
+    exclusiveMaximum: Optional[bool] = None
     minimum: Optional[float] = None
-    exclusiveMinimum: Optional[float] = None
+    exclusiveMinimum: Optional[bool] = None
     maxLength: Optional[int] = Field(None, gte=0)
     minLength: Optional[int] = Field(None, gte=0)
     pattern: Optional[str] = None
diff --git a/squall/openapi/utils.py b/squall/openapi/utils.py
index 6f98ef0..e6a3201 100644
--- a/squall/openapi/utils.py
+++ b/squall/openapi/utils.py
@@ -13,8 +13,9 @@
 from pydantic.utils import lenient_issubclass
 from squall import routing
 from squall.datastructures import DefaultPlaceholder
-from squall.dependencies.models import Dependant
-from squall.dependencies.utils import get_flat_dependant, get_flat_params
+
+# from squall.dependencies.models import Dependant
+# from squall.dependencies.utils import get_flat_dependant, get_flat_params
 from squall.openapi.constants import (
     METHODS_WITH_BODY,
     REF_PREFIX,
@@ -64,17 +65,17 @@
 }
 
 
-def get_openapi_security_definitions(
-    flat_dependant: Dependant,
-) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
-    security_definitions = {}
-    operation_security = []
-    for security_requirement in flat_dependant.security_requirements:
-        security_definition = (security_requirement.security_scheme.model,)
-        security_name = security_requirement.security_scheme.scheme_name
-        security_definitions[security_name] = security_definition
-        operation_security.append({security_name: security_requirement.scopes})
-    return security_definitions, operation_security
+# def get_openapi_security_definitions(
+#     flat_dependant: Dependant,
+# ) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
+#     security_definitions = {}
+#     operation_security = []
+#     for security_requirement in flat_dependant.security_requirements:
+#         security_definition = (security_requirement.security_scheme.model,)
+#         security_name = security_requirement.security_scheme.scheme_name
+#         security_definitions[security_name] = security_definition
+#         operation_security.append({security_name: security_requirement.scopes})
+#     return security_definitions, operation_security
 
 
 def get_openapi_operation_parameters(
@@ -173,21 +174,26 @@ def get_openapi_path(
         current_response_class = route.response_class
     assert current_response_class, "A response class is needed to generate OpenAPI"
     route_response_media_type: Optional[str] = current_response_class.media_type
+
     if route.include_in_schema:
         for method in route.methods:
             operation = get_openapi_operation_metadata(route=route, method=method)
             parameters: List[Dict[str, Any]] = []
-            flat_dependant = get_flat_dependant(route.dependant, skip_repeats=True)
-            security_definitions, operation_security = get_openapi_security_definitions(
-                flat_dependant=flat_dependant
-            )
-            if operation_security:
-                operation.setdefault("security", []).extend(operation_security)
-            if security_definitions:
-                security_schemes.update(security_definitions)
-            all_route_params = get_flat_params(route.dependant)
+            for param in route.head_params:
+                parameters.append(param.spec)
+
+            # flat_dependant = get_flat_dependant(route.dependant, skip_repeats=True)
+            # security_definitions, operation_security = get_openapi_security_definitions(
+            #     flat_dependant=flat_dependant
+            # )
+            # if operation_security:
+            #     operation.setdefault("security", []).extend(operation_security)
+            # if security_definitions:
+            #     security_schemes.update(security_definitions)
+            # all_route_params = get_flat_params(route.dependant)
+
             operation_parameters = get_openapi_operation_parameters(
-                all_route_params=all_route_params, model_name_map=model_name_map
+                all_route_params=[], model_name_map=model_name_map
             )
             parameters.extend(operation_parameters)
             if parameters:
@@ -195,11 +201,12 @@ def get_openapi_path(
                     {param["name"]: param for param in parameters}.values()
                 )
             if method in METHODS_WITH_BODY:
-                request_body_oai = get_openapi_operation_request_body(
-                    body_field=route.body_field, model_name_map=model_name_map
-                )
-                if request_body_oai:
-                    operation["requestBody"] = request_body_oai
+                pass
+                # request_body_oai = get_openapi_operation_request_body(
+                #     body_field=route.body_field, model_name_map=model_name_map
+                # )
+                # if request_body_oai:
+                #     operation["requestBody"] = request_body_oai
             if route.callbacks:
                 callbacks = {}
                 for callback in route.callbacks:
@@ -289,28 +296,28 @@ def get_openapi_path(
                     )
                     deep_dict_update(openapi_response, process_response)
                     openapi_response["description"] = description
-            http422 = str(HTTP_422_UNPROCESSABLE_ENTITY)
-            if (all_route_params or route.body_field) and not any(
-                [
-                    status in operation["responses"]
-                    for status in [http422, "4XX", "default"]
-                ]
-            ):
-                operation["responses"][http422] = {
-                    "description": "Validation Error",
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": REF_PREFIX + "HTTPValidationError"}
-                        }
-                    },
-                }
-                if "ValidationError" not in definitions:
-                    definitions.update(
-                        {
-                            "ValidationError": validation_error_definition,
-                            "HTTPValidationError": validation_error_response_definition,
-                        }
-                    )
+            str(HTTP_422_UNPROCESSABLE_ENTITY)
+            # if (all_route_params or route.body_field) and not any(
+            #     [
+            #         status in operation["responses"]
+            #         for status in [http422, "4XX", "default"]
+            #     ]
+            # ):
+            #     operation["responses"][http422] = {
+            #         "description": "Validation Error",
+            #         "content": {
+            #             "application/json": {
+            #                 "schema": {"$ref": REF_PREFIX + "HTTPValidationError"}
+            #             }
+            #         },
+            #     }
+            #     if "ValidationError" not in definitions:
+            #         definitions.update(
+            #             {
+            #                 "ValidationError": validation_error_definition,
+            #                 "HTTPValidationError": validation_error_response_definition,
+            #             }
+            #         )
             if route.openapi_extra:
                 deep_dict_update(operation, route.openapi_extra)
             path[method.lower()] = operation
@@ -328,19 +335,29 @@ def get_flat_models_from_routes(
         if getattr(route, "include_in_schema", None) and isinstance(
             route, routing.APIRoute
         ):
-            if route.body_field:
-                assert isinstance(
-                    route.body_field, ModelField
-                ), "A request body must be a Pydantic Field"
-                body_fields_from_routes.append(route.body_field)
-            if route.response_field:
-                responses_from_routes.append(route.response_field)
-            if route.response_fields:
-                responses_from_routes.extend(route.response_fields.values())
-            if route.callbacks:
-                callback_flat_models |= get_flat_models_from_routes(route.callbacks)
-            params = get_flat_params(route.dependant)
-            request_fields_from_routes.extend(params)
+            # if route.body_field:
+            #     assert isinstance(
+            #         route.body_field, ModelField
+            #     ), "A request body must be a Pydantic Field"
+            #     body_fields_from_routes.append(route.body_field)
+            # if route.response_field:
+            #     responses_from_routes.append(route.response_field)
+            # if route.response_fields:
+            #     responses_from_routes.extend(route.response_fields.values())
+            # if route.callbacks:
+            #     callback_flat_models |= get_flat_models_from_routes(route.callbacks)
+            # params = get_flat_params(route.dependant)
+            # request_fields_from_routes.extend(params)
+            request_fields_from_routes.extend(
+                [
+                    # {
+                    #     "required": True,
+                    #     "schema": {"title": "Item Id", "type": "string"},
+                    #     "name": "item_id",
+                    #     "in": "path",
+                    # }
+                ]
+            )
 
     flat_models = callback_flat_models | get_flat_models_from_fields(
         body_fields_from_routes + responses_from_routes + request_fields_from_routes,
diff --git a/squall/param_functions.py b/squall/param_functions.py
index 73483da..584edbf 100644
--- a/squall/param_functions.py
+++ b/squall/param_functions.py
@@ -1,4 +1,4 @@
-from typing import Any, Callable, Dict, Optional, Sequence
+from typing import Any, Dict, Optional
 
 from pydantic.fields import Undefined
 from squall import params
@@ -7,7 +7,7 @@
 def Path(  # noqa: N802
     default: Any,
     *,
-    alias: Optional[str] = None,
+    origin: Optional[str] = None,
     title: Optional[str] = None,
     description: Optional[str] = None,
     gt: Optional[float] = None,
@@ -24,7 +24,7 @@ def Path(  # noqa: N802
 ) -> Any:
     return params.Path(
         default=default,
-        alias=alias,
+        origin=origin,
         title=title,
         description=description,
         gt=gt,
@@ -44,7 +44,7 @@ def Path(  # noqa: N802
 def Query(  # noqa: N802
     default: Any,
     *,
-    alias: Optional[str] = None,
+    origin: Optional[str] = None,
     title: Optional[str] = None,
     description: Optional[str] = None,
     gt: Optional[float] = None,
@@ -61,7 +61,7 @@ def Query(  # noqa: N802
 ) -> Any:
     return params.Query(
         default,
-        alias=alias,
+        origin=origin,
         title=title,
         description=description,
         gt=gt,
@@ -81,7 +81,7 @@ def Query(  # noqa: N802
 def Header(  # noqa: N802
     default: Any,
     *,
-    alias: Optional[str] = None,
+    origin: Optional[str] = None,
     convert_underscores: bool = True,
     title: Optional[str] = None,
     description: Optional[str] = None,
@@ -99,7 +99,7 @@ def Header(  # noqa: N802
 ) -> Any:
     return params.Header(
         default,
-        alias=alias,
+        origin=origin,
         convert_underscores=convert_underscores,
         title=title,
         description=description,
@@ -120,7 +120,7 @@ def Header(  # noqa: N802
 def Cookie(  # noqa: N802
     default: Any,
     *,
-    alias: Optional[str] = None,
+    origin: Optional[str] = None,
     title: Optional[str] = None,
     description: Optional[str] = None,
     gt: Optional[float] = None,
@@ -137,7 +137,7 @@ def Cookie(  # noqa: N802
 ) -> Any:
     return params.Cookie(
         default,
-        alias=alias,
+        origin=origin,
         title=title,
         description=description,
         gt=gt,
@@ -159,7 +159,7 @@ def Body(  # noqa: N802
     *,
     embed: bool = False,
     media_type: str = "application/json",
-    alias: Optional[str] = None,
+    origin: Optional[str] = None,
     title: Optional[str] = None,
     description: Optional[str] = None,
     gt: Optional[float] = None,
@@ -177,7 +177,7 @@ def Body(  # noqa: N802
         default,
         embed=embed,
         media_type=media_type,
-        alias=alias,
+        origin=origin,
         title=title,
         description=description,
         gt=gt,
@@ -197,7 +197,7 @@ def Form(  # noqa: N802
     default: Any,
     *,
     media_type: str = "application/x-www-form-urlencoded",
-    alias: Optional[str] = None,
+    origin: Optional[str] = None,
     title: Optional[str] = None,
     description: Optional[str] = None,
     gt: Optional[float] = None,
@@ -214,7 +214,7 @@ def Form(  # noqa: N802
     return params.Form(
         default,
         media_type=media_type,
-        alias=alias,
+        origin=origin,
         title=title,
         description=description,
         gt=gt,
@@ -234,7 +234,7 @@ def File(  # noqa: N802
     default: Any,
     *,
     media_type: str = "multipart/form-data",
-    alias: Optional[str] = None,
+    origin: Optional[str] = None,
     title: Optional[str] = None,
     description: Optional[str] = None,
     gt: Optional[float] = None,
@@ -251,7 +251,7 @@ def File(  # noqa: N802
     return params.File(
         default,
         media_type=media_type,
-        alias=alias,
+        origin=origin,
         title=title,
         description=description,
         gt=gt,
@@ -267,16 +267,16 @@ def File(  # noqa: N802
     )
 
 
-def Depends(  # noqa: N802
-    dependency: Optional[Callable[..., Any]] = None, *, use_cache: bool = True
-) -> Any:
-    return params.Depends(dependency=dependency, use_cache=use_cache)
-
-
-def Security(  # noqa: N802
-    dependency: Optional[Callable[..., Any]] = None,
-    *,
-    scopes: Optional[Sequence[str]] = None,
-    use_cache: bool = True,
-) -> Any:
-    return params.Security(dependency=dependency, scopes=scopes, use_cache=use_cache)
+# def Depends(  # noqa: N802
+#     dependency: Optional[Callable[..., Any]] = None, *, use_cache: bool = True
+# ) -> Any:
+#     return params.Depends(dependency=dependency, use_cache=use_cache)
+#
+#
+# def Security(  # noqa: N802
+#     dependency: Optional[Callable[..., Any]] = None,
+#     *,
+#     scopes: Optional[Sequence[str]] = None,
+#     use_cache: bool = True,
+# ) -> Any:
+#     return params.Security(dependency=dependency, scopes=scopes, use_cache=use_cache)
diff --git a/squall/params.py b/squall/params.py
index 3cab98b..86e4a18 100644
--- a/squall/params.py
+++ b/squall/params.py
@@ -1,225 +1,103 @@
+from decimal import Decimal
 from enum import Enum
-from typing import Any, Callable, Dict, Optional, Sequence
+from typing import Any, Dict, Optional, Union
 
 from pydantic.fields import FieldInfo, Undefined
 
+Number = Union[int, float, Decimal]
 
-class ParamTypes(Enum):
-    query = "query"
-    header = "header"
-    path = "path"
-    cookie = "cookie"
 
+class ValidatorTypes(Enum):
+    numeric = "numeric"
+    string = "string"
 
-class Param(FieldInfo):
-    in_: ParamTypes
+
+class Num(FieldInfo):
+    in_ = ValidatorTypes.numeric
 
     def __init__(
         self,
-        default: Any,
-        *,
-        alias: Optional[str] = None,
-        title: Optional[str] = None,
-        description: Optional[str] = None,
-        gt: Optional[float] = None,
-        ge: Optional[float] = None,
-        lt: Optional[float] = None,
-        le: Optional[float] = None,
-        min_length: Optional[int] = None,
-        max_length: Optional[int] = None,
-        regex: Optional[str] = None,
-        example: Any = Undefined,
-        examples: Optional[Dict[str, Any]] = None,
-        deprecated: Optional[bool] = None,
-        **extra: Any,
+        gt: Optional[Number] = None,
+        ge: Optional[Number] = None,
+        lt: Optional[Number] = None,
+        le: Optional[Number] = None,
     ):
-        self.deprecated = deprecated
-        self.example = example
-        self.examples = examples
-        super().__init__(
-            default,
-            alias=alias,
-            title=title,
-            description=description,
-            gt=gt,
-            ge=ge,
-            lt=lt,
-            le=le,
-            min_length=min_length,
-            max_length=max_length,
-            regex=regex,
-            **extra,
-        )
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}({self.default})"
+        self.in_ = self.in_
+        super().__init__(gt=gt, ge=ge, lt=lt, le=le)
 
 
-class Path(Param):
-    in_ = ParamTypes.path
+class Str(FieldInfo):
+    in_ = ValidatorTypes.string
 
     def __init__(
         self,
-        default: Any,
-        *,
-        alias: Optional[str] = None,
-        title: Optional[str] = None,
-        description: Optional[str] = None,
-        gt: Optional[float] = None,
-        ge: Optional[float] = None,
-        lt: Optional[float] = None,
-        le: Optional[float] = None,
         min_length: Optional[int] = None,
         max_length: Optional[int] = None,
-        regex: Optional[str] = None,
-        example: Any = Undefined,
-        examples: Optional[Dict[str, Any]] = None,
-        deprecated: Optional[bool] = None,
-        **extra: Any,
+        # starts: Optional[AnyStr] = None,
+        # ends: Optional[AnyStr] = None,
     ):
         self.in_ = self.in_
-        super().__init__(
-            ...,
-            alias=alias,
-            title=title,
-            description=description,
-            gt=gt,
-            ge=ge,
-            lt=lt,
-            le=le,
-            min_length=min_length,
-            max_length=max_length,
-            regex=regex,
-            deprecated=deprecated,
-            example=example,
-            examples=examples,
-            **extra,
-        )
+        super().__init__(min_length=min_length, max_length=max_length)
 
 
-class Query(Param):
-    in_ = ParamTypes.query
+class ParamTypes(Enum):
+    param = "path_params"
+    query = "query_params"
+    header = "headers"
+    path = "path_params"
+    cookie = "cookies"
+
+
+class CommonParam(FieldInfo):
+    in_: ParamTypes
 
     def __init__(
         self,
         default: Any,
         *,
-        alias: Optional[str] = None,
+        origin: Optional[str] = None,
         title: Optional[str] = None,
         description: Optional[str] = None,
-        gt: Optional[float] = None,
-        ge: Optional[float] = None,
-        lt: Optional[float] = None,
-        le: Optional[float] = None,
-        min_length: Optional[int] = None,
-        max_length: Optional[int] = None,
-        regex: Optional[str] = None,
+        valid: Optional[Union[Str, Num]] = None,
         example: Any = Undefined,
         examples: Optional[Dict[str, Any]] = None,
         deprecated: Optional[bool] = None,
         **extra: Any,
     ):
+        self.deprecated = deprecated
+        self.example = example
+        self.examples = examples
+        self.origin = origin
+        self.valid = valid
         super().__init__(
             default,
-            alias=alias,
             title=title,
             description=description,
-            gt=gt,
-            ge=ge,
-            lt=lt,
-            le=le,
-            min_length=min_length,
-            max_length=max_length,
-            regex=regex,
-            deprecated=deprecated,
-            example=example,
-            examples=examples,
             **extra,
         )
 
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.default})"
 
-class Header(Param):
-    in_ = ParamTypes.header
 
-    def __init__(
-        self,
-        default: Any,
-        *,
-        alias: Optional[str] = None,
-        convert_underscores: bool = True,
-        title: Optional[str] = None,
-        description: Optional[str] = None,
-        gt: Optional[float] = None,
-        ge: Optional[float] = None,
-        lt: Optional[float] = None,
-        le: Optional[float] = None,
-        min_length: Optional[int] = None,
-        max_length: Optional[int] = None,
-        regex: Optional[str] = None,
-        example: Any = Undefined,
-        examples: Optional[Dict[str, Any]] = None,
-        deprecated: Optional[bool] = None,
-        **extra: Any,
-    ):
-        self.convert_underscores = convert_underscores
-        super().__init__(
-            default,
-            alias=alias,
-            title=title,
-            description=description,
-            gt=gt,
-            ge=ge,
-            lt=lt,
-            le=le,
-            min_length=min_length,
-            max_length=max_length,
-            regex=regex,
-            deprecated=deprecated,
-            example=example,
-            examples=examples,
-            **extra,
-        )
+class Path(CommonParam):
+    in_ = ParamTypes.path
 
 
-class Cookie(Param):
-    in_ = ParamTypes.cookie
+class Param(CommonParam):
+    in_ = ParamTypes.param
 
-    def __init__(
-        self,
-        default: Any,
-        *,
-        alias: Optional[str] = None,
-        title: Optional[str] = None,
-        description: Optional[str] = None,
-        gt: Optional[float] = None,
-        ge: Optional[float] = None,
-        lt: Optional[float] = None,
-        le: Optional[float] = None,
-        min_length: Optional[int] = None,
-        max_length: Optional[int] = None,
-        regex: Optional[str] = None,
-        example: Any = Undefined,
-        examples: Optional[Dict[str, Any]] = None,
-        deprecated: Optional[bool] = None,
-        **extra: Any,
-    ):
-        super().__init__(
-            default,
-            alias=alias,
-            title=title,
-            description=description,
-            gt=gt,
-            ge=ge,
-            lt=lt,
-            le=le,
-            min_length=min_length,
-            max_length=max_length,
-            regex=regex,
-            deprecated=deprecated,
-            example=example,
-            examples=examples,
-            **extra,
-        )
+
+class Query(CommonParam):
+    in_ = ParamTypes.query
+
+
+class Header(CommonParam):
+    in_ = ParamTypes.header
+
+
+class Cookie(CommonParam):
+    in_ = ParamTypes.cookie
 
 
 class Body(FieldInfo):
@@ -229,7 +107,7 @@ def __init__(
         *,
         embed: bool = False,
         media_type: str = "application/json",
-        alias: Optional[str] = None,
+        origin: Optional[str] = None,
         title: Optional[str] = None,
         description: Optional[str] = None,
         gt: Optional[float] = None,
@@ -249,7 +127,7 @@ def __init__(
         self.examples = examples
         super().__init__(
             default,
-            alias=alias,
+            origin=origin,
             title=title,
             description=description,
             gt=gt,
@@ -272,7 +150,7 @@ def __init__(
         default: Any,
         *,
         media_type: str = "application/x-www-form-urlencoded",
-        alias: Optional[str] = None,
+        origin: Optional[str] = None,
         title: Optional[str] = None,
         description: Optional[str] = None,
         gt: Optional[float] = None,
@@ -290,7 +168,7 @@ def __init__(
             default,
             embed=True,
             media_type=media_type,
-            alias=alias,
+            origin=origin,
             title=title,
             description=description,
             gt=gt,
@@ -312,7 +190,7 @@ def __init__(
         default: Any,
         *,
         media_type: str = "multipart/form-data",
-        alias: Optional[str] = None,
+        origin: Optional[str] = None,
         title: Optional[str] = None,
         description: Optional[str] = None,
         gt: Optional[float] = None,
@@ -329,7 +207,7 @@ def __init__(
         super().__init__(
             default,
             media_type=media_type,
-            alias=alias,
+            origin=origin,
             title=title,
             description=description,
             gt=gt,
@@ -345,26 +223,27 @@ def __init__(
         )
 
 
-class Depends:
-    def __init__(
-        self, dependency: Optional[Callable[..., Any]] = None, *, use_cache: bool = True
-    ):
-        self.dependency = dependency
-        self.use_cache = use_cache
-
-    def __repr__(self) -> str:
-        attr = getattr(self.dependency, "__name__", type(self.dependency).__name__)
-        cache = "" if self.use_cache else ", use_cache=False"
-        return f"{self.__class__.__name__}({attr}{cache})"
-
-
-class Security(Depends):
-    def __init__(
-        self,
-        dependency: Optional[Callable[..., Any]] = None,
-        *,
-        scopes: Optional[Sequence[str]] = None,
-        use_cache: bool = True,
-    ):
-        super().__init__(dependency=dependency, use_cache=use_cache)
-        self.scopes = scopes or []
+#
+# class Depends:
+#     def __init__(
+#         self, dependency: Optional[Callable[..., Any]] = None, *, use_cache: bool = True
+#     ):
+#         self.dependency = dependency
+#         self.use_cache = use_cache
+#
+#     def __repr__(self) -> str:
+#         attr = getattr(self.dependency, "__name__", type(self.dependency).__name__)
+#         cache = "" if self.use_cache else ", use_cache=False"
+#         return f"{self.__class__.__name__}({attr}{cache})"
+#
+#
+# class Security(Depends):
+#     def __init__(
+#         self,
+#         dependency: Optional[Callable[..., Any]] = None,
+#         *,
+#         scopes: Optional[Sequence[str]] = None,
+#         use_cache: bool = True,
+#     ):
+#         super().__init__(dependency=dependency, use_cache=use_cache)
+#         self.scopes = scopes or []
diff --git a/squall/requests.py b/squall/requests.py
index 8782215..8c1884e 100644
--- a/squall/requests.py
+++ b/squall/requests.py
@@ -1,6 +1,291 @@
-from starlette.requests import HTTPConnection as HTTPConnection  # noqa: F401
-from starlette.requests import Request as SlRequest  # noqa: F401
+import typing
+from collections.abc import Mapping
+from http import cookies as http_cookies
+from typing import Any, Dict, Optional
 
+import anyio
+import orjson
+from starlette.datastructures import URL, Address, FormData, Headers, QueryParams, State
+from starlette.formparsers import FormParser, MultiPartParser
+from starlette.types import Message, Receive, Scope, Send
 
-class Request(SlRequest):
-    ...
+try:
+    from multipart.multipart import parse_options_header
+except ImportError:  # pragma: nocover
+    parse_options_header = None
+
+
+json_loads = orjson.loads
+
+SERVER_PUSH_HEADERS_TO_COPY = {
+    "accept",
+    "accept-encoding",
+    "accept-language",
+    "cache-control",
+    "user-agent",
+}
+
+
+def cookie_parser(cookie_string: str) -> typing.Dict[str, str]:
+    """
+    This function parses a ``Cookie`` HTTP header into a dict of key/value pairs.
+
+    It attempts to mimic browser cookie parsing behavior: browsers and web servers
+    frequently disregard the spec (RFC 6265) when setting and reading cookies,
+    so we attempt to suit the common scenarios here.
+
+    This function has been adapted from Django 3.1.0.
+    Note: we are explicitly _NOT_ using `SimpleCookie.load` because it is based
+    on an outdated spec and will fail on lots of input we want to support
+    """
+    cookie_dict: typing.Dict[str, str] = {}
+    for chunk in cookie_string.split(";"):
+        if "=" in chunk:
+            key, val = chunk.split("=", 1)
+        else:
+            # Assume an empty name per
+            # https://bugzilla.mozilla.org/show_bug.cgi?id=169091
+            key, val = "", chunk
+        key, val = key.strip(), val.strip()
+        if key or val:
+            # unquote using Python's algorithm.
+            cookie_dict[key] = http_cookies._unquote(val)
+    return cookie_dict
+
+
+class ClientDisconnect(Exception):
+    pass
+
+
+class HTTPConnection(Mapping):
+    """
+    A base class for incoming HTTP connections, that is used to provide
+    any functionality that is common to both `Request` and `WebSocket`.
+    """
+
+    def __init__(self, scope: Scope, receive: Receive = None) -> None:
+        assert scope["type"] in ("http", "websocket")
+        self.scope = scope
+        self.path_params = scope.get("path_params", {})
+
+    def __getitem__(self, key: str) -> typing.Any:
+        return self.scope[key]
+
+    def __iter__(self) -> typing.Iterator[str]:
+        return iter(self.scope)
+
+    def __len__(self) -> int:
+        return len(self.scope)
+
+    # Don't use the `abc.Mapping.__eq__` implementation.
+    # Connection instances should never be considered equal
+    # unless `self is other`.
+    __eq__ = object.__eq__
+    __hash__ = object.__hash__
+
+    @property
+    def app(self) -> typing.Any:
+        return self.scope["app"]
+
+    @property
+    def url(self) -> URL:
+        if not hasattr(self, "_url"):
+            self._url = URL(scope=self.scope)
+        return self._url
+
+    @property
+    def base_url(self) -> URL:
+        if not hasattr(self, "_base_url"):
+            base_url_scope = dict(self.scope)
+            base_url_scope["path"] = "/"
+            base_url_scope["query_string"] = b""
+            base_url_scope["root_path"] = base_url_scope.get(
+                "app_root_path", base_url_scope.get("root_path", "")
+            )
+            self._base_url = URL(scope=base_url_scope)
+        return self._base_url
+
+    @property
+    def headers(self) -> Headers:
+        if not hasattr(self, "_headers"):
+            self._headers = Headers(scope=self.scope)
+        return self._headers
+
+    @property
+    def query_params(self) -> QueryParams:
+        if not hasattr(self, "_query_params"):
+            self._query_params = QueryParams(self.scope["query_string"])
+        return self._query_params
+
+    # @property
+    # def path_params(self) -> dict:
+    #     return self.scope.get("path_params", {})
+
+    @property
+    def cookies(self) -> typing.Dict[str, str]:
+        if not hasattr(self, "_cookies"):
+            cookies: typing.Dict[str, str] = {}
+            cookie_header = self.headers.get("cookie")
+
+            if cookie_header:
+                cookies = cookie_parser(cookie_header)
+            self._cookies = cookies
+        return self._cookies
+
+    @property
+    def client(self) -> Address:
+        host, port = self.scope.get("client") or (None, None)
+        return Address(host=host, port=port)
+
+    @property
+    def session(self) -> Any:
+        assert (
+            "session" in self.scope
+        ), "SessionMiddleware must be installed to access request.session"
+        return self.scope["session"]
+
+    @property
+    def auth(self) -> typing.Any:
+        assert (
+            "auth" in self.scope
+        ), "AuthenticationMiddleware must be installed to access request.auth"
+        return self.scope["auth"]
+
+    @property
+    def user(self) -> typing.Any:
+        assert (
+            "user" in self.scope
+        ), "AuthenticationMiddleware must be installed to access request.user"
+        return self.scope["user"]
+
+    @property
+    def state(self) -> State:
+        if not hasattr(self, "_state"):
+            # Ensure 'state' has an empty dict if it's not already populated.
+            self.scope.setdefault("state", {})
+            # Create a state instance with a reference to the dict in which it should
+            # store info
+            self._state = State(self.scope["state"])
+        return self._state
+
+
+async def empty_receive() -> Message:
+    raise RuntimeError("Receive channel has not been made available")
+
+
+async def empty_send(message: Message) -> None:
+    raise RuntimeError("Send channel has not been made available")
+
+
+class Request(HTTPConnection):
+    _json: Dict[str, Any]
+
+    def __init__(
+        self, scope: Scope, receive: Receive = empty_receive, send: Send = empty_send
+    ):
+        super().__init__(scope)
+        assert scope["type"] == "http"
+        self._receive = receive
+        self._send = send
+        self._stream_consumed = False
+        self._is_disconnected = False
+
+    @property
+    def method(self) -> str:
+        method: str = self.scope["method"]
+        return method
+
+    @property
+    def receive(self) -> Receive:
+        return self._receive
+
+    async def stream(self) -> typing.AsyncGenerator[bytes, None]:
+        if hasattr(self, "_body"):
+            yield self._body
+            yield b""
+            return
+
+        if self._stream_consumed:
+            raise RuntimeError("Stream consumed")
+
+        self._stream_consumed = True
+        while True:
+            message = await self._receive()
+            if message["type"] == "http.request":
+                message_get = message.get
+                body = message_get("body", b"")
+                if body:
+                    yield body
+                if not message_get("more_body", False):
+                    break
+            elif message["type"] == "http.disconnect":
+                self._is_disconnected = True
+                raise ClientDisconnect()
+        yield b""
+
+    async def body(self) -> bytes:
+        body: Optional[bytes] = getattr(self, "_body", None)
+        if body is not None:
+            return body
+
+        chunks = []
+        async for chunk in self.stream():
+            chunks.append(chunk)
+        self._body = body = b"".join(chunks)
+        return body
+
+    async def json(self) -> typing.Any:
+        if hasattr(self, "_json"):
+            return self._json
+
+        body = await self.body()
+        self._json = _json = json_loads(body)
+        return _json
+
+    async def form(self) -> FormData:
+        if not hasattr(self, "_form"):
+            assert (
+                parse_options_header is not None
+            ), "The `python-multipart` library must be installed to use form parsing."
+            content_type_header = self.headers.get("Content-Type")
+            content_type, options = parse_options_header(content_type_header)
+            if content_type == b"multipart/form-data":
+                multipart_parser = MultiPartParser(self.headers, self.stream())
+                self._form = await multipart_parser.parse()
+            elif content_type == b"application/x-www-form-urlencoded":
+                form_parser = FormParser(self.headers, self.stream())
+                self._form = await form_parser.parse()
+            else:
+                self._form = FormData()
+        return self._form
+
+    async def close(self) -> None:
+        form = getattr(self, "_form", None)
+        if form is not None:
+            await form.close()
+
+    async def is_disconnected(self) -> bool:
+        if not self._is_disconnected:
+            message: Message = {}
+
+            # If message isn't immediately available, move on
+            with anyio.CancelScope() as cs:
+                cs.cancel()
+                message = await self._receive()
+
+            if message.get("type") == "http.disconnect":
+                self._is_disconnected = True
+
+        return self._is_disconnected
+
+    async def send_push_promise(self, path: str) -> None:
+        if "http.response.push" in self.scope.get("extensions", {}):
+            raw_headers = []
+            for name in SERVER_PUSH_HEADERS_TO_COPY:
+                for value in self.headers.getlist(name):
+                    raw_headers.append(
+                        (name.encode("latin-1"), value.encode("latin-1"))
+                    )
+            await self._send(
+                {"type": "http.response.push", "path": path, "headers": raw_headers}
+            )
diff --git a/squall/responses.py b/squall/responses.py
index dc87bf9..daa8f4f 100644
--- a/squall/responses.py
+++ b/squall/responses.py
@@ -1,15 +1,19 @@
 import decimal
-from typing import Any
+import typing
+from typing import Any, Dict, List, Optional, Tuple
 
 import orjson
 from pydantic import BaseModel
+from squall.types import Receive, Scope, Send
 from starlette.responses import FileResponse as FileResponse  # noqa
-from starlette.responses import HTMLResponse as HTMLResponse  # noqa
-from starlette.responses import PlainTextResponse as PlainTextResponse  # noqa
 from starlette.responses import RedirectResponse as RedirectResponse  # noqa
-from starlette.responses import Response as Response  # noqa
+from starlette.responses import Response as StarletteResponse  # noqa
 from starlette.responses import StreamingResponse as StreamingResponse  # noqa
 
+json_dumps = orjson.dumps
+json_option = orjson.OPT_NON_STR_KEYS
+json_pretty_option = orjson.OPT_NON_STR_KEYS | orjson.OPT_INDENT_2
+
 
 def default(obj: Any) -> Any:
     if isinstance(obj, BaseModel):
@@ -18,11 +22,86 @@ def default(obj: Any) -> Any:
         return float(obj)
     elif isinstance(obj, set):
         return tuple(obj)
+    elif isinstance(obj, bytes):
+        return obj.decode("utf-8")
     raise TypeError
 
 
+def init_headers(
+    body: bytes,
+    charset: str,
+    media_type: Optional[str] = None,
+    headers: Optional[typing.Mapping[str, str]] = None,
+) -> List[Tuple[bytes, bytes]]:
+    if headers is None:
+        raw_headers: typing.List[typing.Tuple[bytes, bytes]] = []
+        populate_content_length = True
+        populate_content_type = True
+    else:
+        raw_headers = [
+            (k.lower().encode("latin-1"), v.encode("latin-1"))
+            for k, v in headers.items()
+        ]
+        keys = [h[0] for h in raw_headers]
+        populate_content_length = b"content-length" not in keys
+        populate_content_type = b"content-type" not in keys
+
+    append = raw_headers.append
+    if body and populate_content_length:
+        append((b"content-length", str(len(body)).encode()))
+
+    if media_type is not None and populate_content_type:
+        content_type = media_type
+        if media_type[:5] == "text/":
+            content_type += "; charset=" + charset
+        append((b"content-type", content_type.encode()))
+    return raw_headers
+
+
+class Response(StarletteResponse):
+    media_type = None
+    charset: str = "utf-8"
+
+    def __init__(
+        self,
+        content: typing.Any = None,
+        status_code: int = 200,
+        headers: Optional[Dict[str, str]] = None,
+        media_type: Optional[str] = None,
+    ) -> None:
+        self.status_code = status_code
+        if media_type is not None:
+            self.media_type = media_type
+        self.body = body = self.render(content)
+        self.raw_headers = raw_headers = init_headers(
+            body, self.charset, self.media_type, headers
+        )
+        self.send_start = {
+            "type": "http.response.start",
+            "status": status_code,
+            "headers": raw_headers,
+        }
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        await send(self.send_start)
+        await send({"type": "http.response.body", "body": self.body})
+
+
 class JSONResponse(Response):
     media_type = "application/json"
 
     def render(self, content: Any) -> Any:
-        return orjson.dumps(content, default=default, option=orjson.OPT_NON_STR_KEYS)
+        return json_dumps(content, default=default, option=json_option)
+
+
+class PrettyJSONResponse(JSONResponse):
+    def render(self, content: Any) -> Any:
+        return json_dumps(content, default=default, option=json_pretty_option)
+
+
+class HTMLResponse(Response):
+    media_type = "text/html"
+
+
+class PlainTextResponse(Response):
+    media_type = "text/plain"
diff --git a/squall/router.py b/squall/router.py
index 8e25f89..c98049e 100644
--- a/squall/router.py
+++ b/squall/router.py
@@ -1,7 +1,7 @@
-import enum
 import re
 from typing import (
     Any,
+    Awaitable,
     Callable,
     Dict,
     List,
@@ -13,7 +13,6 @@
     Union,
 )
 
-from squall import params
 from squall.datastructures import Default
 from squall.exceptions import HTTPException
 from squall.responses import JSONResponse, PlainTextResponse, RedirectResponse, Response
@@ -21,13 +20,10 @@
 from squall.types import ASGIApp, DecoratedCallable, Receive, Scope, Send
 from squall.utils import get_value_or_default
 from starlette.datastructures import URL
-from starlette.routing import Match as SlMatch
 from starlette.websockets import WebSocketClose
 
-
-class PathPlaceholder(enum.Enum):
-    DYNAMIC = "*"
-    LOCATION = "**"
+PLACEHOLDER_DYNAMIC = "*"
+PLACEHOLDER_LOCATION = "**"
 
 
 class Router:
@@ -35,24 +31,24 @@ def __init__(
         self,
         prefix: str = "",
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         default_response_class: Type[Response] = Default(JSONResponse),
         responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
         routes: Optional[List[Union[APIRoute, APIWebSocketRoute]]] = None,
         route_class: Type[APIRoute] = APIRoute,
         deprecated: Optional[bool] = None,
         include_in_schema: bool = True,
-        dependency_overrides_provider: Optional[Any] = None,
+        # dependency_overrides_provider: Optional[Any] = None,
     ) -> None:
         self._prefix = prefix
         self._tags = tags or []
-        self._dependencies = list(dependencies or []) or []
+        # self._dependencies = list(dependencies or []) or []
         self._default_response_class = default_response_class
         self.route_class = route_class
         self._deprecated = deprecated
         self._include_in_schema = include_in_schema
         self._responses = responses or {}
-        self.dependency_overrides_provider = dependency_overrides_provider
+        # self.dependency_overrides_provider = dependency_overrides_provider
 
         self._routes: List[Union[APIRoute, APIWebSocketRoute]] = routes or []
 
@@ -64,7 +60,7 @@ def add_api_route(
         response_model: Optional[Type[Any]] = None,
         status_code: Optional[int] = None,
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
         response_description: str = "Successful Response",
@@ -87,16 +83,16 @@ def add_api_route(
         current_tags = self._tags.copy()
         if tags:
             current_tags.extend(tags)
-        current_dependencies = self._dependencies.copy()
-        if dependencies:
-            current_dependencies.extend(dependencies)
+        # current_dependencies = self._dependencies.copy()
+        # if dependencies:
+        #     current_dependencies.extend(dependencies)
         route = route_class(
             self._prefix + path,
             endpoint=endpoint,
             response_model=response_model,
             status_code=status_code,
             tags=current_tags,
-            dependencies=current_dependencies,
+            # dependencies=current_dependencies,
             summary=summary,
             description=description,
             response_description=response_description,
@@ -108,7 +104,7 @@ def add_api_route(
             response_class=current_response_class,
             name=name,
             openapi_extra=openapi_extra,
-            dependency_overrides_provider=self.dependency_overrides_provider,
+            # dependency_overrides_provider=self.dependency_overrides_provider,
         )
         self.route_register(route)
 
@@ -120,7 +116,7 @@ def add_route(
         response_model: Optional[Type[Any]] = None,
         status_code: Optional[int] = None,
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
         response_description: str = "Successful Response",
@@ -143,16 +139,16 @@ def add_route(
         current_tags = self._tags.copy()
         if tags:
             current_tags.extend(tags)
-        current_dependencies = self._dependencies.copy()
-        if dependencies:
-            current_dependencies.extend(dependencies)
+        # current_dependencies = self._dependencies.copy()
+        # if dependencies:
+        #     current_dependencies.extend(dependencies)
         route = route_class(
             self._prefix + path,
             endpoint=endpoint,
             response_model=response_model,
             status_code=status_code,
             tags=current_tags,
-            dependencies=current_dependencies,
+            # dependencies=current_dependencies,
             summary=summary,
             description=description,
             response_description=response_description,
@@ -164,7 +160,7 @@ def add_route(
             response_class=current_response_class,
             name=name,
             openapi_extra=openapi_extra,
-            dependency_overrides_provider=self.dependency_overrides_provider,
+            # dependency_overrides_provider=self.dependency_overrides_provider,
         )
         self.route_register(route)
 
@@ -178,7 +174,7 @@ def add_api(
         response_model: Optional[Type[Any]] = None,
         status_code: Optional[int] = None,
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
         response_description: str = "Successful Response",
@@ -208,7 +204,7 @@ def decorator(func: DecoratedCallable) -> DecoratedCallable:
                 response_model=response_model,
                 status_code=status_code,
                 tags=tags,
-                dependencies=dependencies,
+                # dependencies=dependencies,
                 summary=summary,
                 description=description,
                 response_description=response_description,
@@ -236,7 +232,6 @@ def add_ws_route(
             self._prefix + path,
             endpoint=endpoint,
             name=name,
-            dependency_overrides_provider=self.dependency_overrides_provider,
         )
         self.route_register(route)
 
@@ -290,7 +285,7 @@ def get(
         response_model: Optional[Type[Any]] = None,
         status_code: Optional[int] = None,
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
         response_description: str = "Successful Response",
@@ -307,7 +302,7 @@ def get(
             response_model=response_model,
             status_code=status_code,
             tags=tags,
-            dependencies=dependencies,
+            # dependencies=dependencies,
             summary=summary,
             description=description,
             response_description=response_description,
@@ -328,7 +323,7 @@ def put(
         response_model: Optional[Type[Any]] = None,
         status_code: Optional[int] = None,
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
         response_description: str = "Successful Response",
@@ -345,7 +340,7 @@ def put(
             response_model=response_model,
             status_code=status_code,
             tags=tags,
-            dependencies=dependencies,
+            # dependencies=dependencies,
             summary=summary,
             description=description,
             response_description=response_description,
@@ -366,7 +361,7 @@ def post(
         response_model: Optional[Type[Any]] = None,
         status_code: Optional[int] = None,
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
         response_description: str = "Successful Response",
@@ -383,7 +378,7 @@ def post(
             response_model=response_model,
             status_code=status_code,
             tags=tags,
-            dependencies=dependencies,
+            # dependencies=dependencies,
             summary=summary,
             description=description,
             response_description=response_description,
@@ -404,7 +399,7 @@ def delete(
         response_model: Optional[Type[Any]] = None,
         status_code: Optional[int] = None,
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
         response_description: str = "Successful Response",
@@ -421,7 +416,7 @@ def delete(
             response_model=response_model,
             status_code=status_code,
             tags=tags,
-            dependencies=dependencies,
+            # dependencies=dependencies,
             summary=summary,
             description=description,
             response_description=response_description,
@@ -442,7 +437,7 @@ def options(
         response_model: Optional[Type[Any]] = None,
         status_code: Optional[int] = None,
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
         response_description: str = "Successful Response",
@@ -459,7 +454,7 @@ def options(
             response_model=response_model,
             status_code=status_code,
             tags=tags,
-            dependencies=dependencies,
+            # dependencies=dependencies,
             summary=summary,
             description=description,
             response_description=response_description,
@@ -480,7 +475,7 @@ def head(
         response_model: Optional[Type[Any]] = None,
         status_code: Optional[int] = None,
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
         response_description: str = "Successful Response",
@@ -497,7 +492,7 @@ def head(
             response_model=response_model,
             status_code=status_code,
             tags=tags,
-            dependencies=dependencies,
+            # dependencies=dependencies,
             summary=summary,
             description=description,
             response_description=response_description,
@@ -518,7 +513,7 @@ def patch(
         response_model: Optional[Type[Any]] = None,
         status_code: Optional[int] = None,
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
         response_description: str = "Successful Response",
@@ -535,7 +530,7 @@ def patch(
             response_model=response_model,
             status_code=status_code,
             tags=tags,
-            dependencies=dependencies,
+            # dependencies=dependencies,
             summary=summary,
             description=description,
             response_description=response_description,
@@ -556,7 +551,7 @@ def trace(
         response_model: Optional[Type[Any]] = None,
         status_code: Optional[int] = None,
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
         response_description: str = "Successful Response",
@@ -574,7 +569,7 @@ def trace(
             response_model=response_model,
             status_code=status_code,
             tags=tags,
-            dependencies=dependencies,
+            # dependencies=dependencies,
             summary=summary,
             description=description,
             response_description=response_description,
@@ -594,7 +589,7 @@ def __init__(
         self,
         prefix: str = "",
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         default_response_class: Type[Response] = Default(JSONResponse),
         responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
         routes: Optional[List[Union[APIRoute, APIWebSocketRoute]]] = None,
@@ -609,14 +604,14 @@ def __init__(
         super(RootRouter, self).__init__(
             prefix=prefix,
             tags=tags,
-            dependencies=dependencies,
+            # dependencies=dependencies,
             default_response_class=default_response_class,
             routes=routes,
             route_class=route_class,
             deprecated=deprecated,
             include_in_schema=include_in_schema,
             responses=responses,
-            dependency_overrides_provider=dependency_overrides_provider,
+            # dependency_overrides_provider=dependency_overrides_provider,
         )
         self.redirect_slashes = redirect_slashes
         self.default = default or self.not_found
@@ -624,7 +619,7 @@ def __init__(
         self._fast_path_route_ws: Dict[str, Any] = {}
         # self.lifespan_context: Callable[[Any], AsyncContextManager] = RouterLifespan(self)
 
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+    def __call__(self, scope: Scope, receive: Receive, send: Send) -> Awaitable[Any]:
         """
         The main entry point to the Router class.
         """
@@ -643,14 +638,13 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
             # Determine if any route matches the incoming scope,
             # and hand over to the matching route if found.
             match, child_scope = route.matches(scope)
-            if match == SlMatch.FULL:
+            if match:
                 scope.update(child_scope)
-                await route.handle(scope, receive, send)
-                return
+                return route.app(scope, receive, send)
 
         # for location in reversed(_locations):
         #     match, child_scope = location.matches(scope)
-        #     if match == SlMatch.FULL:
+        #     if match:
         #         scope.update(child_scope)
         #         await location.handle(scope, receive, send)
         #         return
@@ -667,13 +661,13 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
             )
             for route in routes:
                 match, child_scope = route.matches(redirect_scope)
-                if match != SlMatch.NONE:
+                if match:
                     redirect_url = URL(scope=redirect_scope)
                     response = RedirectResponse(url=str(redirect_url))
-                    await response(scope, receive, send)
-                    return
+                    return response(scope, receive, send)
+                    # return
 
-        await self.default(scope, receive, send)
+        return self.default(scope, receive, send)
 
     @staticmethod
     async def not_found(scope: Scope, receive: Receive, send: Send) -> None:
@@ -693,15 +687,11 @@ async def not_found(scope: Scope, receive: Receive, send: Send) -> None:
 
     @staticmethod
     def _get_fast_path_octets(path: str) -> List[str]:
-        no_regex = re.sub(r"(\([^)]*\))", PathPlaceholder.DYNAMIC.value, path)
-        no_format = re.sub(r"{([^}]*)}", PathPlaceholder.DYNAMIC.value, no_regex)
+        no_regex = re.sub(r"(\([^)]*\))", PLACEHOLDER_DYNAMIC, path)
+        no_format = re.sub(r"{([^}]*)}", PLACEHOLDER_DYNAMIC, no_regex)
         result = []
         for i in no_format.strip("/").split("/"):
-            value = (
-                PathPlaceholder.DYNAMIC.value
-                if PathPlaceholder.DYNAMIC.value in i
-                else i
-            )
+            value = PLACEHOLDER_DYNAMIC if PLACEHOLDER_DYNAMIC in i else i
             result.append(value)
         return result
 
@@ -713,8 +703,8 @@ def _add_fast_path_route(
         for octet in self._get_fast_path_octets(route.path):
             if octet not in layer:
                 layer[octet] = {}
-                if octet != "*":
-                    layer[octet]["*"] = {}
+                if octet != PLACEHOLDER_DYNAMIC:
+                    layer[octet][PLACEHOLDER_DYNAMIC] = {}
             layer = layer[octet]
 
         if "#routes#" not in layer:
@@ -748,9 +738,9 @@ def get_http_routes(
         locations = []
         try:
             for key in path.strip("/").split("/"):
-                last = last.get(key) or last[PathPlaceholder.DYNAMIC.value]
-                if PathPlaceholder.LOCATION.value in last:
-                    locations.append(last[PathPlaceholder.LOCATION.value])
+                last = last.get(key) or last[PLACEHOLDER_DYNAMIC]
+                if PLACEHOLDER_LOCATION in last:
+                    locations.append(last[PLACEHOLDER_LOCATION])
         except KeyError:
             return [], locations
         routes: List[APIRoute] = last.get("#routes#", {}).get(method, [])
@@ -760,7 +750,7 @@ def get_ws_routes(self, path: str) -> List[APIWebSocketRoute]:
         last = self._fast_path_route_ws
         try:
             for key in path.strip("/").split("/"):
-                last = last.get(key) or last[PathPlaceholder.DYNAMIC.value]
+                last = last.get(key) or last[PLACEHOLDER_DYNAMIC]
         except KeyError:
             return []
         return last.get("#routes#", [])
diff --git a/squall/routing.py b/squall/routing.py
index 4480c7c..174a2ed 100644
--- a/squall/routing.py
+++ b/squall/routing.py
@@ -1,8 +1,8 @@
 import asyncio
-import email.message
 import enum
 import inspect
-import json
+import re
+from decimal import Decimal
 from typing import (
     Any,
     Callable,
@@ -10,46 +10,42 @@
     Dict,
     List,
     Optional,
-    Sequence,
+    Pattern,
     Set,
+    Tuple,
     Type,
     Union,
 )
 
+from orjson import JSONDecodeError
 from pydantic.error_wrappers import ErrorWrapper, ValidationError
-from pydantic.fields import ModelField, Undefined
-from squall import params
+from pydantic.fields import ModelField
 from squall.datastructures import Default, DefaultPlaceholder
-from squall.dependencies.models import Dependant
-from squall.dependencies.utils import (
-    get_body_field,
-    get_dependant,
-    get_parameterless_sub_dependant,
-    solve_dependencies,
+from squall.exceptions import (
+    HTTPException,
+    RequestHeadValidationError,
+    RequestPayloadValidationError,
 )
-from squall.exceptions import RequestValidationError, WebSocketRequestValidationError
 from squall.openapi.constants import STATUS_CODES_WITH_NO_BODY
 from squall.requests import Request
 from squall.responses import JSONResponse, Response
+from squall.routing_.utils import (
+    HeadParam,
+    get_handler_body_params,
+    get_handler_head_params,
+)
 from squall.utils import (
     create_cloned_field,
     create_response_field,
     generate_operation_id_for_path,
 )
+from squall.validators.head import Validator
 from starlette.concurrency import run_in_threadpool
-from starlette.exceptions import HTTPException
 from starlette.routing import BaseRoute as SlBaseRoute
-from starlette.routing import Mount as Mount  # noqa
 from starlette.routing import Route as SlRoute
 from starlette.routing import WebSocketRoute as SlWebSocketRoute
-from starlette.routing import (
-    compile_path,
-    get_name,
-    iscoroutinefunction_or_partial,
-    websocket_session,
-)
-from starlette.status import WS_1008_POLICY_VIOLATION
-from starlette.types import ASGIApp, Receive, Scope, Send
+from starlette.routing import get_name, websocket_session
+from starlette.types import Receive, Scope, Send
 from starlette.websockets import WebSocket
 
 
@@ -65,155 +61,282 @@ class NoMatchFound(Exception):
     """
 
 
-#
-# class Match(enum.Enum):
-#     NONE = 0
-#     PARTIAL = 1
-#     FULL = 2
-#
-#
-# class Event(enum.Enum):
-#     STARTUP = "startup"
-#     SHUTDOWN = "shutdown"
+from starlette.convertors import CONVERTOR_TYPES, Convertor
+
+# Match parameters in URL paths, eg. '{param}', and '{param:int}'
+PARAM_REGEX = re.compile("{([a-zA-Z_][a-zA-Z0-9_]*)(:[a-zA-Z_][a-zA-Z0-9_]*)?}")
 
 
-def request_response(func: Callable[..., Any]) -> ASGIApp:
+def compile_path(
+    path: str,
+) -> Tuple[Pattern[str], str, Dict[str, Convertor]]:
     """
-    Takes a function or coroutine `func(request) -> response`,
-    and returns an ASGI application.
+    Given a path string, like: "/{username:str}", return a three-tuple
+    of (regex, format, {param_name:convertor}).
+    regex:      "/(?P<username>[^/]+)"
+    format:     "/{username}"
+    convertors: {"username": StringConvertor()}
     """
-    is_coroutine = iscoroutinefunction_or_partial(func)
+    path_regex = "^"
+    path_format = ""
+    duplicated_params = set()
 
-    async def app(scope: Scope, receive: Receive, send: Send) -> None:
-        request = Request(scope, receive=receive, send=send)
-        if is_coroutine:
-            response = await func(request)
-        else:
-            response = await run_in_threadpool(func, request)
-        await response(scope, receive, send)
+    idx = 0
+    param_convertors = {}
+    for match in PARAM_REGEX.finditer(path):
+        param_name, convertor_type = match.groups("str")
+        convertor_type = convertor_type.lstrip(":")
+        assert (
+            convertor_type in CONVERTOR_TYPES
+        ), f"Unknown path convertor '{convertor_type}'"
+        convertor = CONVERTOR_TYPES[convertor_type]
 
-    return app
+        path_regex += re.escape(path[idx : match.start()])
+        path_regex += f"(?P<{param_name}>{convertor.regex})"
 
+        path_format += path[idx : match.start()]
+        path_format += "{%s}" % param_name
 
-async def run_endpoint_function(
-    *, dependant: Dependant, values: Dict[str, Any], is_coroutine: bool
-) -> Any:
-    # Only called by get_request_handler. Has been split into its own function to
-    # facilitate profiling endpoints, since inner functions are harder to profile.
-    assert dependant.call is not None, "dependant.call must be a function"
+        if param_name in param_convertors:
+            duplicated_params.add(param_name)
 
-    if is_coroutine:
-        return await dependant.call(**values)
-    else:
-        return await run_in_threadpool(dependant.call, **values)
+        param_convertors[param_name] = convertor
+
+        idx = match.end()
+
+    if duplicated_params:
+        names = ", ".join(sorted(duplicated_params))
+        ending = "s" if len(duplicated_params) > 1 else ""
+        raise ValueError(f"Duplicated param name{ending} {names} at path {path}")
+
+    path_regex += re.escape(path[idx:]) + "$"
+    path_format += path[idx:]
+
+    return re.compile(path_regex), path_format, param_convertors
 
 
 def get_request_handler(
-    dependant: Dependant,
-    body_field: Optional[ModelField] = None,
+    endpoint: Callable[..., Any],
+    head_validator: Callable[..., Any],
+    body_fields: List[Any],
+    # body_field: Optional[ModelField] = None,
     status_code: Optional[int] = None,
     response_class: Union[Type[Response], DefaultPlaceholder] = Default(JSONResponse),
     dependency_overrides_provider: Optional[Any] = None,
     response_field: Optional[ModelField] = None,
 ) -> Callable[[Request], Coroutine[Any, Any, Response]]:
-    assert dependant.call is not None, "dependant.call must be a function"
-    is_coroutine = asyncio.iscoroutinefunction(dependant.call)
-    is_body_form = body_field and isinstance(body_field.field_info, params.Form)
+    is_coroutine = asyncio.iscoroutinefunction(endpoint)
+    # is_body_form = body_field and isinstance(body_field.field_info, params.Form)
     if isinstance(response_class, DefaultPlaceholder):
         actual_response_class: Type[Response] = response_class.value
     else:
         actual_response_class = response_class
 
-    async def app(request: Request) -> Response:
+    async def app(scope: Scope, receive: Receive, send: Send) -> None:
+        request = Request(scope, receive=receive, send=send)
+
+        # Head validation
+        kwargs, errors = head_validator(request)
+        if errors:
+            raise RequestHeadValidationError(errors)
+
+        # Body fields and request object
+        form = None
         try:
-            body: Any = None
-            if body_field:
-                if is_body_form:
-                    body = await request.form()
-                else:
-                    body_bytes = await request.body()
-                    if body_bytes:
-                        json_body: Any = Undefined
-                        content_type_value = request.headers.get("content-type")
-                        if not content_type_value:
-                            json_body = await request.json()
-                        else:
-                            message = email.message.Message()
-                            message["content-type"] = content_type_value
-                            if message.get_content_maintype() == "application":
-                                subtype = message.get_content_subtype()
-                                if subtype == "json" or subtype.endswith("+json"):
-                                    json_body = await request.json()
-                        if json_body != Undefined:
-                            body = json_body
-                        else:
-                            body = body_bytes
-        except json.JSONDecodeError as e:
-            raise RequestValidationError([ErrorWrapper(e, ("body", e.pos))], body=e.doc)
+            for field in body_fields:
+                kind = field["kind"]
+                if kind == "request":
+                    kwargs[field["name"]] = request
+                elif kind == "model":
+                    body = await request.json()
+                    kwargs[field["name"]] = field["model_class"](**body)
+                elif kind == "body":
+                    ct = request.headers.get("content-type")
+                    if ct is not None and ct[-4:] == "json":
+                        kwargs[field["name"]] = await request.json()
+                    else:
+                        kwargs[field["name"]] = await request.body()
+                elif kind == "form":
+                    if form is None:
+                        form = await request.form()
+                    kwargs[field["name"]] = form.get(field["name"])
+
+        except JSONDecodeError as e:
+            raise RequestPayloadValidationError(
+                [ErrorWrapper(e, ("body", e.pos))], body=e.doc
+            )
+        except ValidationError as e:
+            raise RequestPayloadValidationError([ErrorWrapper(e, ("body",))])
         except Exception as e:
             raise HTTPException(
                 status_code=400, detail="There was an error parsing the body"
             ) from e
-        solved_result = await solve_dependencies(
-            request=request,
-            dependant=dependant,
-            body=body,
-            dependency_overrides_provider=dependency_overrides_provider,
-        )
-        values, errors, background_tasks, sub_response, _ = solved_result
-        if errors:
-            raise RequestValidationError(errors, body=body)
+
+        if is_coroutine:
+            raw_response = await endpoint(**kwargs)
         else:
-            raw_response = await run_endpoint_function(
-                dependant=dependant, values=values, is_coroutine=is_coroutine
+            raw_response = await run_in_threadpool(endpoint, **kwargs)
+
+        if isinstance(raw_response, Response):
+            await raw_response(scope, receive, send)
+            return
+            # return raw_response
+
+        response_args: Dict[str, Any] = {}
+        # If status_code was set, use it, otherwise use the default from the
+        # response class, in the case of redirect it's 307
+        if response_field is not None:
+            response_value, response_errors = response_field.validate(
+                raw_response, {}, loc=("response",)
             )
-            if isinstance(raw_response, Response):
-                if raw_response.background is None:
-                    raw_response.background = background_tasks
-                return raw_response
-
-            response_args: Dict[str, Any] = {"background": background_tasks}
-            # If status_code was set, use it, otherwise use the default from the
-            # response class, in the case of redirect it's 307
-            if response_field is not None:
-                response_value, response_errors = response_field.validate(
-                    raw_response, {}, loc=("response",)
-                )
-                if response_errors:
-                    raise ValidationError([response_errors], response_field.type_)
-            else:
-                response_value = raw_response
-
-            if status_code is not None:
-                response_args["status_code"] = status_code
-            response = actual_response_class(response_value, **response_args)
-            response.headers.raw.extend(sub_response.headers.raw)
-            if sub_response.status_code:
-                response.status_code = sub_response.status_code
-            return response
+            if response_errors:
+                raise ValidationError([response_errors], response_field.type_)
+        else:
+            response_value = raw_response
+
+        if status_code is not None:
+            response_args["status_code"] = status_code
+        response = actual_response_class(response_value, **response_args)
+        await response(scope, receive, send)
+
+        # try:
+        #     body: Any = None
+        #     if True: # body_field:
+        #         if False: # is_body_form:
+        #             body = await request.form()
+        #         else:
+        #             body_bytes = await request.body()
+        #             if body_bytes:
+        #                 json_body: Any = Undefined
+        #                 content_type_value = request.headers.get("content-type")
+        #                 if not content_type_value:
+        #                     json_body = await request.json()
+        #                 else:
+        #                     message = email.message.Message()
+        #                     message["content-type"] = content_type_value
+        #                     if message.get_content_maintype() == "application":
+        #                         subtype = message.get_content_subtype()
+        #                         if subtype == "json" or subtype.endswith("+json"):
+        #                             json_body = await request.json()
+        #                 if json_body != Undefined:
+        #                     body = json_body
+        #                 else:
+        #                     body = body_bytes
+        # except json.JSONDecodeError as e:
+        #     raise RequestPayloadValidationError([ErrorWrapper(e, ("body", e.pos))], body=e.doc)
+        # except Exception as e:
+        #     raise HTTPException(
+        #         status_code=400, detail="There was an error parsing the body"
+        #     ) from e
+
+        # # solved_result = await solve_dependencies(
+        # #     request=request,
+        # #     dependant=dependant,
+        # #     body=body,
+        # #     dependency_overrides_provider=dependency_overrides_provider,
+        # # )
+        # values, errors, background_tasks, sub_response, _ = solved_result
+        # if errors:
+        #     raise RequestPayloadValidationError(errors, body=body)
+        # else:
+        # if True:
+        #     if is_coroutine:
+        #         raw_response = await endpoint(**kwargs)
+        #     else:
+        #         raw_response = await run_in_threadpool(endpoint, **kwargs)
+        #
+        #     if isinstance(raw_response, Response):
+        #         await raw_response(scope, receive, send)
+        #         return
+        #         # return raw_response
+        #
+        #     response_args: Dict[str, Any] = {}
+        #     # If status_code was set, use it, otherwise use the default from the
+        #     # response class, in the case of redirect it's 307
+        #     if response_field is not None:
+        #         response_value, response_errors = response_field.validate(
+        #             raw_response, {}, loc=("response",)
+        #         )
+        #         if response_errors:
+        #             raise ValidationError([response_errors], response_field.type_)
+        #     else:
+        #         response_value = raw_response
+        #
+        #     if status_code is not None:
+        #         response_args["status_code"] = status_code
+        #     response = actual_response_class(response_value, **response_args)
+        #     # response.headers.raw.extend(sub_response.headers.raw)
+        #     # if sub_response.status_code:
+        #     #     response.status_code = sub_response.status_code
+        #     await response(scope, receive, send)
 
     return app
 
 
 def get_websocket_app(
-    dependant: Dependant, dependency_overrides_provider: Optional[Any] = None
+    # dependant: Dependant,
+    # dependency_overrides_provider: Optional[Any] = None
 ) -> Callable[[WebSocket], Coroutine[Any, Any, Any]]:
     async def app(websocket: WebSocket) -> None:
-        solved_result = await solve_dependencies(
-            request=websocket,
-            dependant=dependant,
-            dependency_overrides_provider=dependency_overrides_provider,
-        )
-        values, errors, _, _2, _3 = solved_result
-        if errors:
-            await websocket.close(code=WS_1008_POLICY_VIOLATION)
-            raise WebSocketRequestValidationError(errors)
-        assert dependant.call is not None, "dependant.call must be a function"
-        await dependant.call(**values)
+        pass
+        # solved_result = await solve_dependencies(
+        #     request=websocket,
+        #     dependant=dependant,
+        #     dependency_overrides_provider=dependency_overrides_provider,
+        # )
+        # values, errors, _, _2, _3 = solved_result
+        # if errors:
+        #     await websocket.close(code=WS_1008_POLICY_VIOLATION)
+        #     raise WebSocketRequestValidationError(errors)
+        # assert dependant.call is not None, "dependant.call must be a function"
+        # await dependant.call(**values)
 
     return app
 
 
+def build_head_validator(head_params: List[HeadParam]) -> Callable[..., Any]:
+    v = Validator(
+        args=["request"],
+        convertors={
+            "int": int,
+            "float": float,
+            "Decimal": Decimal,
+            "str": str,
+            "bytes": lambda a: a.encode("utf-8"),
+        },
+    )
+    for param in head_params:
+        v.add_rule(
+            attribute=param.source,
+            name=param.name,
+            key=param.origin,
+            check=param.validate,
+            convert=param.convertor,
+            as_list=param.is_array,
+            default=param.default,
+            **param.statements
+            # gt=param.get("gt"),
+            # ge=param.get("ge"),
+            # lt=param.get("lt"),
+            # le=param.get("le"),
+            # min_length=param.get("min_length"),
+            # max_length=param.get("max_length"),
+        )
+        print(
+            dict(
+                attribute=param.source,
+                name=param.name,
+                key=param.origin,
+                check=param.validate,
+                convert=param.convertor,
+                as_list=param.is_array,
+                default=param.default,
+                **param.statements,
+            )
+        )
+    return v.build()
+
+
 class Route(SlRoute):
     def __init__(
         self,
@@ -232,6 +355,12 @@ def __init__(
             include_in_schema=include_in_schema,
         )
 
+    def matches(self, scope: Scope) -> Tuple[bool, Scope]:
+        match = self.path_regex.match(scope["path"])
+        if match:
+            return True, {"endpoint": self.endpoint, "path_params": match.groupdict()}
+        return False, {}
+
 
 class APIWebSocketRoute(WebSocketRoute):
     def __init__(
@@ -245,11 +374,11 @@ def __init__(
         self.path = self._path_origin = path
         self.endpoint = endpoint
         self.name = get_name(endpoint) if name is None else name
-        self.dependant = get_dependant(path=path, call=self.endpoint)
+        # self.dependant = get_dependant(path=path, call=self.endpoint)
         self.app = websocket_session(
             get_websocket_app(
-                dependant=self.dependant,
-                dependency_overrides_provider=dependency_overrides_provider,
+                # dependant=self.dependant,
+                # dependency_overrides_provider=dependency_overrides_provider,
             )
         )
         self.path_regex, self.path_format, self.param_convertors = compile_path(path)
@@ -263,6 +392,12 @@ def add_path_prefix(self, prefix: str) -> None:
             self.path
         )
 
+    def matches(self, scope: Scope) -> Tuple[bool, Scope]:
+        match = self.path_regex.match(scope["path"])
+        if match:
+            return True, match.groupdict()
+        return False, {}
+
 
 class APIRoute(Route):
     def __init__(
@@ -273,7 +408,7 @@ def __init__(
         response_model: Optional[Type[Any]] = None,
         status_code: Optional[int] = None,
         tags: Optional[List[str]] = None,
-        dependencies: Optional[Sequence[params.Depends]] = None,
+        # dependencies: Optional[Sequence[params.Depends]] = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
         response_description: str = "Successful Response",
@@ -295,6 +430,9 @@ def __init__(
             status_code = int(status_code)
         self.path = self._path_origin = path
         self.endpoint = endpoint
+        self.head_params = get_handler_head_params(endpoint)
+        self.head_validator = build_head_validator(self.head_params)
+        self.body_fields = get_handler_body_params(endpoint)
         self.name = get_name(endpoint) if name is None else name
         self.path_regex, self.path_format, self.param_convertors = compile_path(path)
         if methods is None:
@@ -327,7 +465,7 @@ def __init__(
             self.secure_cloned_response_field = None
         self.status_code = status_code
         self.tags = tags or []
-        self.dependencies = list(dependencies) if dependencies else []
+        # self.dependencies = list(dependencies) if dependencies else []
         self.summary = summary
         self.description = description or inspect.cleandoc(self.endpoint.__doc__ or "")
         # if a "form feed" character (page break) is found in the description text,
@@ -356,26 +494,33 @@ def __init__(
         self.response_class = response_class
 
         assert callable(endpoint), "An endpoint must be a callable"
-        self.dependant = get_dependant(path=self.path_format, call=self.endpoint)
-        for depends in self.dependencies[::-1]:
-            self.dependant.dependencies.insert(
-                0,
-                get_parameterless_sub_dependant(depends=depends, path=self.path_format),
-            )
-        self.body_field = get_body_field(dependant=self.dependant, name=self.unique_id)
+
+        # self.dependant = get_dependant(path=self.path_format, call=self.endpoint)
+        # for depends in self.dependencies[::-1]:
+        #     self.dependant.dependencies.insert(
+        #         0,
+        #         get_parameterless_sub_dependant(depends=depends, path=self.path_format),
+        #     )
+        # self.body_field = get_body_field(dependant=self.dependant, name=self.unique_id)
+
         self.dependency_overrides_provider = dependency_overrides_provider
         self.callbacks = callbacks
-        self.app = request_response(self.get_route_handler())
+        self.app = self.get_route_handler()
         self.openapi_extra = openapi_extra
 
+        # self.match_hack = (self.path_regex.match, self.endpoint)
+
     def get_route_handler(self) -> Callable[[Request], Coroutine[Any, Any, Response]]:
         return get_request_handler(
-            dependant=self.dependant,
-            body_field=self.body_field,
+            endpoint=self.endpoint,
+            # dependant=self.dependant,
+            # body_field=self.body_field,
             status_code=self.status_code,
             response_class=self.response_class,
             dependency_overrides_provider=self.dependency_overrides_provider,
             response_field=self.response_field,
+            head_validator=self.head_validator,
+            body_fields=self.body_fields,
         )
 
     def set_defaults(self) -> None:
diff --git a/squall/dependencies/__init__.py b/squall/routing_/__init__.py
similarity index 100%
rename from squall/dependencies/__init__.py
rename to squall/routing_/__init__.py
diff --git a/squall/routing_/utils.py b/squall/routing_/utils.py
new file mode 100644
index 0000000..47fa960
--- /dev/null
+++ b/squall/routing_/utils.py
@@ -0,0 +1,259 @@
+import inspect
+import typing
+from dataclasses import is_dataclass
+from decimal import Decimal
+from enum import Enum
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+    get_args,
+    get_origin,
+)
+
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo, Undefined
+from squall.params import Body, CommonParam, File, Form, Num, Str
+from squall.requests import Request
+
+
+class ParameterSourceType(Enum):
+    query = "query"
+    header = "header"
+    path = "path"
+    cookie = "cookie"
+
+
+# class ParameterVariableType(Enum):
+#     int = "integer"
+#     Decimal = "number"
+#     float = "number"
+#     bool = "boolean"
+#     str = "string"
+#     bytes = "string"
+
+
+type_mapping: Dict[str, str] = {
+    "int": "integer",
+    "Decimal": "number",
+    "float": "number",
+    "bool": "boolean",
+    "str": "string",
+    "bytes": "string",
+}
+
+
+class HeadParam:
+    def __init__(self, name: str, value: inspect.Parameter, source: str) -> None:
+        self._annotation = value.annotation
+        self._default = value.default
+        self._empty = value.empty
+
+        self.name = name
+        self.source = source
+        self.is_array, self.convertor = self.get_convertor()
+        self.validate, self.statements = self.get_validation_statements()
+
+    @property
+    def origin(self) -> str:
+        return getattr(self._default, "origin", None) or self.name
+
+    @property
+    def default(self) -> Any:
+        default = Ellipsis
+        if isinstance(self._default, CommonParam):
+            default = self._default.default
+        elif type(self._default) in (int, float, Decimal, str, bytes, type(None)):
+            default = self._default
+        return default
+
+    def get_validation_statements(self) -> Tuple[Optional[str], Dict[str, Any]]:
+        validate, statements = None, {}
+        if hasattr(self._default, "valid") and isinstance(
+            self._default.valid, (Num, Str)
+        ):
+            validate = self._default.valid.in_.value
+            for constraint in self._default.valid.get_constraints():
+                value = getattr(self._default.valid, constraint)
+                if value is not None:
+                    statements[constraint] = value
+        return validate, statements
+
+    def get_convertor(self) -> Tuple[bool, str]:
+        is_array, convertor = False, "str"
+        args, origin = get_args(self._annotation), get_origin(self._annotation)
+        if origin is Union:
+            if type(None) in args:
+                if get_origin(args[0]) == list:
+                    is_array, _convertor = True, get_args(args[0])[0]
+                else:
+                    is_array, _convertor = False, args[0]
+                convertor = getattr(_convertor, "__name__", None)
+        elif origin == list:
+            try:
+                is_array, convertor = True, args[0].__name__
+            except Exception:
+                """List[Any] should be implemented"""
+        elif (
+            hasattr(self._annotation, "__name__")
+            and self._annotation.__name__ != "_empty"
+        ):
+            convertor = self._annotation.__name__
+        else:
+            assert not origin, f"Convertor for {self.name} unknown"
+        return is_array, convertor
+
+    @property
+    def spec(self) -> Dict[str, Any]:
+        source_mapping = {
+            "path_params": "path",
+            "query_params": "query",
+            "headers": "header",
+            "cookies": "cookie",
+        }
+
+        item: Dict[str, Any] = {}
+        item["type"] = type_mapping.get(self.convertor, "string")
+
+        schema: Dict[str, Any]
+        if self.is_array:
+            schema = {"type": "array", "items": item}
+        else:
+            schema = item
+            if self.statements.get("ge") is not None:
+                schema["minimum"] = self.statements["ge"]
+                schema["exclusiveMinimum"] = False
+            elif self.statements.get("gt") is not None:
+                schema["minimum"] = self.statements["gt"]
+                schema["exclusiveMinimum"] = True
+
+            if self.statements.get("le") is not None:
+                schema["maximum"] = self.statements["le"]
+                schema["exclusiveMaximum"] = False
+            elif self.statements.get("lt") is not None:
+                schema["maximum"] = self.statements["lt"]
+                schema["exclusiveMaximum"] = True
+
+        result = {
+            "required": self.default == Ellipsis,
+            "schema": schema,
+            "name": self.origin or self.name,
+            "in": source_mapping[self.source],
+        }
+
+        description = getattr(self._default, "description", None)
+        if description is not None:
+            result["description"] = description
+
+        example = getattr(self._default, "example", None)
+        if example != Undefined and example:
+            result["example"] = example
+
+        examples = getattr(self._default, "examples", None)
+        if examples:
+            result["examples"] = examples
+
+        deprecated = getattr(self._default, "deprecated", None)
+        if deprecated:
+            result["deprecated"] = True
+
+        return result
+
+
+def get_handler_head_params(func: Callable[..., Any]) -> List[HeadParam]:
+    signature = inspect.signature(func)
+    results = []
+    for k, v in signature.parameters.items():
+        source = None
+        if isinstance(v.default, CommonParam):
+            source = v.default.in_.value
+        elif v.default is v.empty:
+            res = get_annotation_affiliation(v.annotation)
+            if res is None:
+                source = "path_params"
+        elif type(v.default) in (int, float, Decimal, str, bytes, type(None)):
+            source = "path_params"
+
+        if source is not None:
+            results.append(HeadParam(name=k, value=v, source=source))
+
+    return results
+
+
+def get_annotation_affiliation(annotation: Any) -> typing.Optional[Any]:
+    """Helper for classifying affiliation of parameter
+
+    :param annotation: annotation record
+    :returns: classified value or None
+    """
+    args, origin = get_args(annotation), get_origin(annotation)
+    if origin and origin == list:
+        annotation = args[0]
+
+    if annotation == Request:
+        return "request"
+    elif inspect.isclass(annotation) and issubclass(annotation, BaseModel):
+        return "model"
+    elif inspect.isclass(annotation) and is_dataclass(annotation):
+        return "model"
+    elif isinstance(annotation, FieldInfo):
+        return "model"
+    # elif isinstance(v.default, (Form, File)):
+    #     return "form"
+    return None
+
+
+def get_handler_body_params(func: Callable[..., Any]) -> List[Dict[str, Any]]:
+    """Reads meta information from callable inspection.
+    Filter out only parameters that appear from BODY.
+    Provides all necessary data for build validation.
+
+    :param func: callable for inspection
+    """
+    signature = inspect.signature(func)
+    results = []
+    for k, v in signature.parameters.items():
+        param: Dict[str, Any] = {"name": k}
+        annotation = v.annotation
+
+        if annotation == Request:
+            param["kind"] = "request"
+        elif inspect.isclass(annotation) and issubclass(annotation, BaseModel):
+            param["kind"] = "model"
+            param["model_class"] = annotation
+        elif inspect.isclass(annotation) and is_dataclass(annotation):
+            param["kind"] = "model"
+            param["model_class"] = annotation
+        elif isinstance(annotation, FieldInfo):
+            param["kind"] = "field"
+            param["model_class"] = annotation
+        elif isinstance(v.default, (Form, File)):
+            param["kind"] = "form"
+            param["model_class"] = annotation
+            # param['origin'] = v.default
+        elif isinstance(v.default, Body):
+            param["kind"] = "body"
+        else:
+            continue
+
+        results.append(param)
+
+    return results
+
+
+class MyModel(BaseModel):
+    a: int
+
+
+if __name__ == "__main__":
+
+    def func(req: Request, a: MyModel) -> None:
+        pass
+
+    from pprint import pprint
+
+    pprint(get_handler_body_params(func))
diff --git a/squall/validators/ast_helpers.py b/squall/validators/ast_helpers.py
index fc1cdba..a7df071 100644
--- a/squall/validators/ast_helpers.py
+++ b/squall/validators/ast_helpers.py
@@ -8,8 +8,12 @@ def setitem(
     value: typing.Any,
 ) -> ast.Assign:
     """Set dictionary item value.
-
     Generates following code: `entity_name[key] = value`
+
+    :param entity_name: dictionary variable name
+    :param key: dictionary key or list index
+    :param value: value expression
+    :returns: an assign expression
     """
     subscript = ast.Subscript(
         value=ast.Name(id=entity_name, ctx=ast.Load()),
@@ -24,31 +28,46 @@ def getitem(
     entity_name: str, key: typing.Union[ast.Constant, ast.Subscript]
 ) -> ast.Subscript:
     """Get dictionary item value.
-
     Generates following code: `entity_name[key]`
+
+    :param entity_name: dictionary variable name
+    :param key: dictionary key or list index
+    :returns: a subscript expression
     """
     return ast.Subscript(
         value=ast.Name(id=entity_name, ctx=ast.Load()), slice=key, ctx=ast.Load()
     )
 
 
-def getattribute(entity_name: str, attribute: str) -> ast.Attribute:
+def getattribute(
+    entity_name: str, attributes: typing.List[str]
+) -> typing.Union[ast.Name, ast.Attribute]:
     """Get object attribute.
 
-    Generates following code: `entity_name.attribute`
+    Generates following code:
+        getattribute(entity_name, [attribute]) -> `entity_name.attribute`
+        getattribute(entity_name, [attribute, get]) -> `entity_name.attribute.get`
+
+    :param entity_name: dictionary variable name
+    :param attributes: list of attributes names
     """
-    return ast.Attribute(
-        value=ast.Name(id=entity_name, ctx=ast.Load()),
-        attr=attribute,
-        ctx=ast.Load(),
+    value: typing.Union[ast.Name, ast.Attribute] = ast.Name(
+        id=entity_name, ctx=ast.Load()
     )
+    for attribute in attributes:
+        value = ast.Attribute(
+            value=value,
+            attr=attribute,
+            ctx=ast.Load(),
+        )
+    return value
 
 
 def call(
     entity_name: str,
-    attribute: typing.Optional[str] = None,
+    attributes: typing.Optional[typing.List[str]] = None,
     args: typing.Optional[typing.List[typing.Any]] = None,
-    is_expression: bool = False,
+    is_standalone: bool = False,
 ) -> typing.Union[ast.Call, ast.Expr]:
     """Generates function or attribute calling.
     Use is is_expression=True if the call is not a part of another expression
@@ -56,15 +75,20 @@ def call(
     Without attributes and args: `entity_name()`
     Without attribute: `entity_name(args)`
     With attribute and args: `entity_name.attribute(args)`
+
+    :param entity_name: dictionary variable name
+    :param attributes: list of attributes names
+    :param args: list of arguments expressions
+    :param is_standalone: is a part of another expression or not. True if not
     """
     args = args or []
     func: typing.Union[ast.Name, ast.Attribute]
-    if attribute is None:
-        func = ast.Name(id=entity_name, ctx=ast.Load())
+    if attributes:
+        func = getattribute(entity_name, attributes)
     else:
-        func = getattribute(entity_name, attribute)
+        func = ast.Name(id=entity_name, ctx=ast.Load())
 
-    if is_expression:
+    if is_standalone:
         return ast.Expr(value=ast.Call(func=func, args=args, keywords=[]))
     return ast.Call(func=func, args=args, keywords=[])
 
@@ -73,9 +97,24 @@ def append(list_name: str, value: typing.Any) -> ast.Expr:
     """Appends item to given list
 
     Generates following code: `list_name.append(value)`
+    :param list_name: list variable name
+    :param value: expression for getting of value that should be appended
+    :returns: append expression ast
     """
     expr = call(
-        entity_name=list_name, attribute="append", args=[value], is_expression=True
+        entity_name=list_name, attributes=["append"], args=[value], is_standalone=True
     )
     assert isinstance(expr, ast.Expr)  # MyPy hack
     return expr
+
+
+def assign(name: str, value: typing.Any) -> ast.Assign:
+    """Assign value to the given variable name
+
+    Generates the following code: `name = value`
+
+    :param name: name of variable which should get the value
+    :param value: get target value expression
+    :returns: assign ast
+    """
+    return ast.Assign(targets=[ast.Name(id=name, ctx=ast.Store())], value=value)
diff --git a/squall/validators/head.py b/squall/validators/head.py
new file mode 100644
index 0000000..a6b74fe
--- /dev/null
+++ b/squall/validators/head.py
@@ -0,0 +1,446 @@
+import ast
+import typing
+from types import CodeType, FunctionType
+
+from squall.validators.ast_helpers import append, assign, call, getattribute, setitem
+
+Number = typing.Union[int, float]
+
+
+class Validator:
+    """Provides interface for building validation function.
+
+    Example:
+        ```
+        >>> v = Validator(
+        >>>     args=["request"],
+        >>>     convertors={
+        >>>         "int": int,
+        >>>         "str": lambda a: a.decode("utf-8") if type(a) == bytes else str(a)
+        >>>     }
+        >>> )
+        >>> v.add_rule("numeric", "path_params", "orders", name="my_orders", gt=20)
+        >>> v.add_rule("string", "path_params", "name",
+        >>>            min_length=3, max_length=5, default="anon", convert="str")
+        >>> validator = v.build()
+        >>> param = {"orders": 30, "name": b"Some", "useless1": 1, "useless2": 40}
+        >>> validator(request)
+        ({'my_orders': 30, 'name': 'Some'}, [])
+        >>> param = {"orders": 20, "useless1": 1, "useless2": 40}
+        >>> validator(request)
+        ({'name': 'anon'}, [('param', 'orders', 'Validation error')])
+    """
+
+    def __init__(
+        self,
+        args: typing.List[str],
+        convertors: typing.Dict[str, typing.Callable[..., typing.Any]],
+    ) -> None:
+        self.args = args
+        assert len(self.args) > 0, "No input parameters names configured."
+        self.convertors = convertors
+        self.rules: typing.List[typing.Any] = []
+
+        # self.getters used to build definitions of getters
+        # ('headers', True) -> `headers_getlist = request.headers.getlist`
+        # ('headers', False) -> `headers_get = request.headers.get`
+        self.getters: typing.Set[typing.Tuple[str, bool]] = set()
+
+    def add_rule(
+        self,
+        check: str,
+        attribute: str,
+        key: str,
+        as_list: bool = False,
+        name: typing.Optional[str] = None,
+        convert: typing.Optional[typing.Any] = None,
+        default: typing.Optional[typing.Any] = Ellipsis,
+        # Numeric arguments
+        gt: typing.Optional[Number] = None,
+        ge: typing.Optional[Number] = None,
+        lt: typing.Optional[Number] = None,
+        le: typing.Optional[Number] = None,
+        # String arguments
+        min_length: typing.Optional[int] = None,
+        max_length: typing.Optional[int] = None,
+    ) -> None:
+        """
+        Adds new validation rule.
+
+        :param check: type of check. At the moment two available `numeric`, `string`
+        :param attribute: source dict name from validator parameters
+        :param key: key of source dict to retrieve the checked value
+        :param as_list: result expected as list
+        :param name: key name for results dict
+        :param convert: convertor name. Must be defined during instance initialisation.
+        :param default: default value to put if value is None or absent.
+                        ATTN! There is no checks for defaults
+                        Ellipsis means field is mandatory
+        :param gt: Numeric only. Checked value should be grater than
+        :param ge: Numeric only. Checked value should be grater than or equal
+        :param lt: Numeric only. Checked value should be less than
+        :param le: Numeric only. Checked value should be less than or equal
+        :param min_length: String only. Checked value length should be more than or equal
+        :param max_length: String only. Checked value length should be less than or equal
+        """
+        self.getters.add((attribute, as_list))
+        name = name or key
+        assert (
+            not convert or convert in self.convertors
+        ), f"Convertor for {name} unknown"
+        # Adds code: `candidate = <attribute>_<get|getlist>(key, Ellipsis)`
+        getter = f"{attribute}_getlist" if as_list else f"{attribute}_get"
+        args = [ast.Constant(value=key)]
+        if not as_list:
+            args.append(ast.Constant(value=Ellipsis))
+        candidate_value = call(getter, args=args)
+        self.rules.append(assign("candidate", candidate_value))
+
+        save = setitem("results", name, ast.Name(id="candidate", ctx=ast.Load()))
+
+        if check == "numeric":
+            rule = self.validate_numeric(
+                on_success=[save],
+                on_failure=[self.add_violate(attribute, key, "Validation error")],
+                gt=gt,
+                ge=ge,
+                lt=lt,
+                le=le,
+            )
+        elif check == "string":
+            rule = self.validate_string(
+                on_success=[save],
+                on_failure=[self.add_violate(attribute, key, "Validation error")],
+                min_length=min_length,
+                max_length=max_length,
+            )
+        else:
+            rule = [save]
+
+        checker = self.main_branching(
+            default=default,
+            on_undefined=[self.add_violate(attribute, key, f"Mandatory field missed")],
+            on_default=[setitem("results", name, ast.Constant(value=default))],
+            on_defined=[
+                self.convert_candidate(
+                    on_success=rule,
+                    on_failure=[
+                        self.add_violate(attribute, key, f"Cast of `{convert}` failed")
+                    ],
+                    func=convert,
+                    as_list=as_list,
+                )
+            ],
+        )
+
+        self.rules.append(checker)
+
+    @classmethod
+    def convert_candidate(
+        cls,
+        on_success: typing.Any,
+        on_failure: typing.Any,
+        func: typing.Optional[str] = None,
+        as_list: bool = False,
+    ) -> ast.Try:
+        """
+        Builds code for conversion with try, except, else logic.
+        In case of exception prevents further checks and writes violate record
+
+        :param on_success: code part for execution after success conversion
+        :param on_failure: code part for execution after conversion failed
+        :param func: convertor function name. Must be defined during instance initialisation.
+        :param as_list: should be cast func applied to each element in sequence
+        """
+        body: typing.List[typing.Union[ast.Pass, ast.Expr, ast.Call, ast.Assign]]
+        expression: typing.Union[ast.Call, ast.Expr, ast.ListComp]
+        if func is None:
+            body = [ast.Pass()]
+        else:
+            if as_list:
+                expression = cls.map(func, ast.Name(id="candidate", ctx=ast.Load()))
+                body = [assign("candidate", value=expression)]
+            else:
+                expression = call(func, args=[ast.Name(id="candidate", ctx=ast.Load())])
+                body = [assign("candidate", value=expression)]
+
+        return ast.Try(
+            body=body,
+            handlers=[ast.ExceptHandler(body=on_failure)],
+            orelse=on_success,
+            finalbody=[],
+        )
+
+    @staticmethod
+    def map(
+        func: str, seq: typing.Union[ast.Call, ast.Subscript, ast.Name]
+    ) -> ast.ListComp:
+        """Map function to each sequence element and outputs result as a list.
+        Generates the following code: `[func(i) for i in seq]`
+
+        :param func: callable name
+        :param seq: expression for get the sequence
+        """
+        return ast.ListComp(
+            elt=call(func, args=[ast.Name(id="i", ctx=ast.Load())]),
+            generators=[
+                ast.comprehension(
+                    target=ast.Name(id="i", ctx=ast.Store()),
+                    iter=seq,
+                    ifs=[],
+                    is_async=0,
+                )
+            ],
+        )
+
+    @staticmethod
+    def copy_to_results(attribute: str, key: str, name: str) -> ast.Assign:
+        """
+        Copy item value form source dict to results.
+        Represents the following code `results[name] = source[key]`
+
+        :param attribute: source dict name from validator parameters
+        :param key: key of source dict to retrieve the checked value
+        :param name: results dict key name
+        """
+        return setitem(
+            "results",
+            key=name,
+            value=call(
+                entity_name="request",
+                attributes=[attribute, "get"],
+                args=[ast.Constant(value=key), ast.Constant(value=Ellipsis)],
+            ),
+        )
+
+    @staticmethod
+    def validate_numeric(
+        on_success: typing.List[typing.Any],
+        on_failure: typing.List[typing.Any],
+        gt: typing.Optional[Number] = None,
+        ge: typing.Optional[Number] = None,
+        lt: typing.Optional[Number] = None,
+        le: typing.Optional[Number] = None,
+    ) -> typing.List[typing.Any]:
+        """
+        Numeric validator
+
+        :param on_success: statements for run if check is success
+        :param on_failure: statements for run if check is fail
+        :param gt: value must be grater than
+        :param ge: value must be grater than or equal
+        :param lt: value must be less than
+        :param le: value must be less than or equal
+        :returns: list of expressions for execution
+        """
+        ops: typing.List[typing.Union[ast.Gt, ast.GtE]] = []
+        comparators: typing.List[typing.Union[ast.Constant, ast.Name]] = []
+        if lt is not None:
+            comparators.append(ast.Constant(value=lt))
+            ops.append(ast.Gt())
+        elif le is not None:
+            comparators.append(ast.Constant(value=le))
+            ops.append(ast.GtE())
+
+        comparators.append(ast.Name(id="candidate", ctx=ast.Load()))
+
+        if gt is not None:
+            comparators.append(ast.Constant(value=gt))
+            ops.append(ast.Gt())
+        if ge is not None:
+            comparators.append(ast.Constant(value=ge))
+            ops.append(ast.GtE())
+
+        if not ops:
+            return on_success
+
+        compare = ast.Compare(left=comparators[0], ops=ops, comparators=comparators[1:])
+        return [
+            ast.If(
+                test=compare,
+                body=on_success,
+                orelse=on_failure,
+            )
+        ]
+
+    @staticmethod
+    def validate_string(
+        on_success: typing.List[typing.Any],
+        on_failure: typing.List[typing.Any],
+        min_length: typing.Optional[int] = None,
+        max_length: typing.Optional[int] = None,
+    ) -> typing.List[typing.Any]:
+        """
+        String validator
+
+        :param on_success: statements for run if check is success
+        :param on_failure: statements for run if check is fail
+        :param min_length: value length must be grater than or equal
+        :param max_length: value length must be less than or equal
+        :returns: list of expressions for execution
+        """
+        ops: typing.List[typing.Union[ast.Gt, ast.GtE]] = []
+        comparators: typing.List[
+            typing.Union[ast.Constant, ast.Name, ast.Call, ast.Expr]
+        ] = []
+
+        if max_length is not None:
+            comparators.append(ast.Constant(value=max_length))
+            ops.append(ast.GtE())
+
+        comparators.append(call("len", args=[ast.Name(id="candidate", ctx=ast.Load())]))
+
+        if min_length is not None:
+            comparators.append(ast.Constant(value=min_length))
+            ops.append(ast.GtE())
+
+        if not ops:
+            return on_success
+
+        compare = ast.Compare(left=comparators[0], ops=ops, comparators=comparators[1:])
+        return [
+            ast.If(
+                test=compare,
+                body=on_success,
+                orelse=on_failure,
+            ),
+        ]
+
+    @staticmethod
+    def add_violate(attribute: str, name: str, reason: str) -> ast.Expr:
+        """Writes record to violations list
+
+        Produce following code: `violates.append(source, key, reason)`
+        Example:
+            >>> add_violate('headers','content-length', 'Cast of `int` failed')
+
+        :param attribute: source attribute name
+        :param name: target parameter name
+        :param reason: violation reason
+        """
+        message = ast.Tuple(
+            elts=[
+                ast.Constant(value=attribute),
+                ast.Constant(value=name),
+                ast.Constant(value=reason),
+                ast.Name(id="candidate", ctx=ast.Load()),
+            ],
+            ctx=ast.Load(),
+        )
+        return append("violates", value=message)
+
+    @staticmethod
+    def main_branching(
+        default: typing.Any,
+        on_undefined: typing.List[typing.Any],
+        on_default: typing.List[typing.Any],
+        on_defined: typing.List[typing.Any],
+    ) -> ast.If:
+        """The first line of making decision
+
+        Generates following code:
+            >>> if candidate == ... and default == ...:
+            >>>    <on_undefined>
+            >>> elif candidate == ...:
+            >>>    <on_default>
+            >>> else:
+            >>>    <on_defined>
+        """
+        candidate = ast.Name(id="candidate", ctx=ast.Load())
+        undefined = ast.Constant(value=Ellipsis)
+        default = ast.Constant(value=default)
+        candidate_cmp = ast.Compare(
+            left=candidate, ops=[ast.Eq()], comparators=[undefined]
+        )
+        default_cmp = ast.Compare(left=default, ops=[ast.Eq()], comparators=[undefined])
+
+        return ast.If(
+            test=ast.BoolOp(op=ast.And(), values=[candidate_cmp, default_cmp]),
+            body=on_undefined,
+            orelse=[ast.If(test=candidate_cmp, body=on_default, orelse=on_defined)],
+        )
+
+    def build_getters(self) -> typing.List[ast.Assign]:
+        """
+        Builds definition of getters for reduce attribute lookups
+
+        Example:
+            >>> self.getters = {
+            >>>     ('headers', True),
+            >>>     ('path_params', False),
+            >>>     ('query_params', True),
+            >>> }
+            Will generate following code
+            >>> headers_getlist = request.headers.getlist
+            >>> path_params_get = request.headers.get
+            >>> query_params_getlist = request.query_params.getlist
+        """
+        assigns = []
+        for attribute, as_list in self.getters:
+            getter = "getlist" if as_list else "get"
+            expr = assign(
+                f"{attribute}_{getter}", getattribute("request", [attribute, getter])
+            )
+            assigns.append(expr)
+        return assigns
+
+    def build(self) -> FunctionType:
+        """Builds validator function"""
+        rows: typing.List[typing.Union[ast.Return, ast.Assign, ast.If]] = []
+        rows.extend(self.build_getters())
+        defs = [
+            {"name": "results", "exp": ast.Dict(keys=[], values=[]), "returns": True},
+            {
+                "name": "violates",
+                "exp": ast.List(elts=[], ctx=ast.Load()),
+                "returns": True,
+            },
+        ]
+        assign = ast.Assign()
+        assign.targets = [
+            ast.Tuple(
+                elts=[ast.Name(id=i["name"], ctx=ast.Store()) for i in defs],
+                ctx=ast.Store(),
+            )
+        ]
+        assign.value = ast.Tuple(elts=[i["exp"] for i in defs], ctx=ast.Load())
+        rows.append(assign)
+        rows.extend(self.rules)
+        rows.append(
+            ast.Return(
+                value=ast.Tuple(
+                    elts=[
+                        ast.Name(id=i["name"], ctx=ast.Load())
+                        for i in defs
+                        if i["returns"]
+                    ],
+                    ctx=ast.Load(),
+                )
+            )
+        )
+
+        function_ast = ast.FunctionDef(
+            name="validator",
+            args=ast.arguments(
+                args=[ast.arg(i) for i in self.args],
+                vararg=None,
+                kwarg=None,
+                defaults=[],
+                kwonlyargs=[],
+                kw_defaults=[],
+                posonlyargs=[],
+            ),
+            body=rows,
+            type_ignores=[],
+            decorator_list=[],
+        )
+        module_ast = ast.Module(body=[function_ast], type_ignores=[])
+        ast.fix_missing_locations(module_ast)
+
+        module_code = compile(module_ast, "<not_a_file>", "exec")
+        function_code = [c for c in module_code.co_consts if isinstance(c, CodeType)][0]
+
+        return FunctionType(
+            function_code,
+            globals={"len": len, **self.convertors},
+        )
diff --git a/squall/validators/inputs.py b/squall/validators/inputs.py
deleted file mode 100644
index 0dd9fe7..0000000
--- a/squall/validators/inputs.py
+++ /dev/null
@@ -1,345 +0,0 @@
-import ast
-import typing
-from types import CodeType, FunctionType
-
-from squall.validators.ast_helpers import append, call, getitem, setitem
-
-Number = typing.Union[int, float]
-
-
-class Validator:
-    """Provides interface for building validation function.
-
-    Example:
-        ```
-        >>> v = Validator(
-        >>>     args=["param"],
-        >>>     convertors={
-        >>>         "int": int,
-        >>>         "str": lambda a: a.decode("utf-8") if type(a) == bytes else str(a)
-        >>>     }
-        >>> )
-        >>> v.add_rule("numeric", "param", "orders", name="my_orders", gt=20)
-        >>> v.add_rule("string", "param", "name",
-        >>>            min_length=3, max_length=5, default="anon", convert="str")
-        >>> validator = v.build()
-        >>> param = {"orders": 30, "name": b"Some", "useless1": 1, "useless2": 40}
-        >>> validator(param)
-        ({'my_orders': 30, 'name': 'Some'}, [])
-        >>> param = {"orders": 20, "useless1": 1, "useless2": 40}
-        >>> validator(param)
-        ({'name': 'anon'}, [('param', 'orders', 'Validation error')])
-    """
-
-    def __init__(
-        self,
-        args: typing.List[str],
-        convertors: typing.Dict[str, typing.Callable[..., typing.Any]],
-    ) -> None:
-        self.args = args
-        assert len(self.args) > 0, "No input parameters names configured."
-        self.convertors = convertors
-        self.rules: typing.List[typing.Any] = []
-
-    def add_rule(
-        self,
-        check: str,
-        source: str,
-        key: str,
-        name: typing.Optional[str] = None,
-        optional: bool = False,
-        convert: typing.Optional[typing.Any] = None,
-        default: typing.Optional[typing.Any] = None,
-        # Numeric arguments
-        gt: typing.Optional[Number] = None,
-        ge: typing.Optional[Number] = None,
-        lt: typing.Optional[Number] = None,
-        le: typing.Optional[Number] = None,
-        # String arguments
-        min_length: typing.Optional[int] = None,
-        max_length: typing.Optional[int] = None,
-    ) -> None:
-        """
-        Adds new validation rule.
-
-        :param check: type of check. At the moment two available `numeric`, `string`
-        :param source: source dict name from validator parameters
-        :param key: key of source dict to retrieve the checked value
-        :param name: key name for results dict
-        :param optional: allow None or key to be absent
-        :param convert: convertor name. Must be defined during instance initialisation.
-        :param default: default value to put if value is None or absent.
-                        ATTN! There is no checks for defaults
-        :param gt: Numeric only. Checked value should be grater than
-        :param ge: Numeric only. Checked value should be grater than or equal
-        :param lt: Numeric only. Checked value should be less than
-        :param le: Numeric only. Checked value should be less than or equal
-        :param min_length: String only. Checked value length should be more than or equal
-        :param max_length: String only. Checked value length should be less than or equal
-        """
-        assert source in self.args
-        name = name or key
-        on_none: typing.List[typing.Union[ast.Expr, ast.Pass, ast.Assign]] = []
-        if default is not None:
-            on_none.append(setitem("results", name, ast.Constant(value=default)))
-        else:
-            on_none.append(
-                ast.Pass() if optional else self.add_violate(name, "Can't be None")
-            )
-        rule: typing.Optional[typing.List[typing.Any]]
-        self.rules.append(self.copy_to_results(source, key, name))
-
-        if check == "numeric":
-            rule = self.handle_numeric(name, gt=gt, ge=ge, lt=lt, le=le)
-        elif check == "string":
-            rule = self.handle_string(
-                name, min_length=min_length, max_length=max_length
-            )
-        if rule is not None:
-            if convert is not None:
-                rule = [self.try_convert(name, convert, than=rule)]
-            self.rules.append(self.if_none(name, on_none, rule))
-
-    def try_convert(self, name: str, func: str, than: typing.Any) -> ast.Try:
-        """
-        Builds code for conversion with try, except, else logic.
-        In case of exception prevents further checks and writes violate record
-
-        :param name: target parameter name
-        :param func: convertor function name. Must be defined during instance initialisation.
-        :param than: code part for execution after success conversion
-        """
-        _try = ast.Try(finalbody=[], orelse=than)
-        _try.handlers = [
-            ast.ExceptHandler(body=[self.add_violate(name, f"Cast of `{func}` failed")])
-        ]
-        _try.body = [
-            setitem(
-                entity_name="results",
-                key=name,
-                value=call(func, args=[getitem("results", ast.Constant(value=name))]),
-            ),
-        ]
-        return _try
-
-    def if_none(
-        self,
-        name: str,
-        on_true: typing.List[typing.Any],
-        on_false: typing.List[typing.Any],
-    ) -> ast.If:
-        """
-        Builds following statement:
-            ```
-            if source.get(key) is None:
-                on_true
-            else:
-                on_false
-            ```
-        :param name: target parameter name
-        :param on_true: list of expressions for execute if value is None
-        :param on_false: list of expressions for execute if value is not None
-        """
-        return ast.If(
-            test=ast.Compare(
-                left=call("results", attribute="get", args=[ast.Constant(value=name)]),
-                ops=[ast.Is()],
-                comparators=[ast.Constant(value=None)],
-            ),
-            body=on_true,
-            orelse=on_false,
-        )
-
-    @staticmethod
-    def copy_to_results(source: str, key: str, name: str) -> ast.Assign:
-        """
-        Copy item value form source dict to results.
-        Represents following code `results[name] = source[key]`
-
-        :param source: source dict name from validator parameters
-        :param key: key of source dict to retrieve the checked value
-        :param name: results dict key name
-        """
-        return setitem(
-            "results",
-            key=name,
-            value=call(
-                entity_name=source,
-                attribute="get",
-                args=[ast.Constant(value=key), ast.Constant(value=None)],
-            ),
-        )
-
-    def handle_numeric(
-        self,
-        name: str,
-        gt: typing.Optional[Number] = None,
-        ge: typing.Optional[Number] = None,
-        lt: typing.Optional[Number] = None,
-        le: typing.Optional[Number] = None,
-    ) -> typing.Optional[typing.List[ast.If]]:
-        """
-        Numeric validator
-
-        :param name: key name for results dict
-        :param gt: value must be grater than
-        :param ge: value must be grater than or equal
-        :param lt: value must be less than
-        :param le: value must be less than or equal
-        """
-        ops: typing.List[typing.Union[ast.Gt, ast.GtE]] = []
-        comparators: typing.List[typing.Union[ast.Constant, ast.Subscript]] = []
-        if lt is not None:
-            comparators.append(ast.Constant(value=lt))
-            ops.append(ast.Gt())
-        elif le is not None:
-            comparators.append(ast.Constant(value=le))
-            ops.append(ast.GtE())
-
-        comparators.append(getitem("results", ast.Constant(value=name)))
-
-        if gt is not None:
-            comparators.append(ast.Constant(value=gt))
-            ops.append(ast.Gt())
-        if ge is not None:
-            comparators.append(ast.Constant(value=ge))
-            ops.append(ast.GtE())
-
-        if not ops:
-            return None
-
-        compare = ast.Compare(left=comparators[0], ops=ops, comparators=comparators[1:])
-        #        produce = self.copy_to_results(source, key, name)
-        return [
-            ast.If(
-                test=ast.UnaryOp(op=ast.Not(), operand=compare),
-                body=[self.add_violate(name, "Validation error")],
-                orelse=[],
-            )
-        ]
-
-    def handle_string(
-        self,
-        name: str,
-        min_length: typing.Optional[int] = None,
-        max_length: typing.Optional[int] = None,
-    ) -> typing.Optional[typing.List[typing.Union[ast.If, ast.Assign]]]:
-        """
-        String validator
-
-        :param name: key name for results dict
-        :param min_length: value length must be grater than or equal
-        :param max_length: value length must be less than or equal
-        """
-        get_length = ast.Assign(
-            targets=[ast.Name(id=f"{name}_len", ctx=ast.Store())],
-            value=ast.Call(
-                func=ast.Name(id="len", ctx=ast.Load()),
-                args=[getitem("results", ast.Constant(value=name))],
-                keywords=[],
-            ),
-        )
-
-        ops: typing.List[typing.Union[ast.Gt, ast.GtE]] = []
-        comparators: typing.List[typing.Union[ast.Constant, ast.Name]] = []
-        if max_length is not None:
-            comparators.append(ast.Constant(value=max_length))
-            ops.append(ast.GtE())
-
-        comparators.append(ast.Name(id=f"{name}_len", ctx=ast.Load()))
-
-        if min_length is not None:
-            comparators.append(ast.Constant(value=min_length))
-            ops.append(ast.GtE())
-
-        if not ops:
-            return None
-
-        compare = ast.Compare(left=comparators[0], ops=ops, comparators=comparators[1:])
-        return [
-            get_length,
-            ast.If(
-                test=ast.UnaryOp(op=ast.Not(), operand=compare),
-                body=[self.add_violate(name, "Validation error")],
-                orelse=[],
-            ),
-        ]
-
-    @staticmethod
-    def add_violate(name: str, reason: str) -> ast.Expr:
-        """Writes record to violations list
-
-        Produce following code: `violates.append(source, key, reason)`
-        Example:
-            >>> add_violate('content_length', 'Cast of `int` failed')
-
-        :param name: target parameter name
-        :param reason: violation reason
-        """
-        message = ast.Tuple(
-            elts=[
-                ast.Constant(value=name),
-                ast.Constant(value=reason),
-            ],
-            ctx=ast.Load(),
-        )
-        return append("violates", value=message)
-
-    def build(self) -> FunctionType:
-        """Builds validator function"""
-        rows: typing.List[typing.Union[ast.Return, ast.Assign, ast.If]] = []
-        defs = [
-            {"name": "results", "exp": ast.Dict(keys=[], values=[]), "returns": True},
-            {
-                "name": "violates",
-                "exp": ast.List(elts=[], ctx=ast.Load()),
-                "returns": True,
-            },
-        ]
-        assign = ast.Assign()
-        assign.targets = [
-            ast.Tuple(
-                elts=[ast.Name(id=i["name"], ctx=ast.Store()) for i in defs],
-                ctx=ast.Store(),
-            )
-        ]
-        assign.value = ast.Tuple(elts=[i["exp"] for i in defs], ctx=ast.Load())
-        rows.append(assign)
-        rows.extend(self.rules)
-        rows.append(
-            ast.Return(
-                value=ast.Tuple(
-                    elts=[
-                        ast.Name(id=i["name"], ctx=ast.Load())
-                        for i in defs
-                        if i["returns"]
-                    ],
-                    ctx=ast.Load(),
-                )
-            )
-        )
-
-        function_ast = ast.FunctionDef(
-            name="validator",
-            args=ast.arguments(
-                args=[ast.arg(i) for i in self.args],
-                vararg=None,
-                kwarg=None,
-                defaults=[],
-                kwonlyargs=[],
-                kw_defaults=[],
-                posonlyargs=[],
-            ),
-            body=rows,
-            type_ignores=[],
-            decorator_list=[],
-        )
-        module_ast = ast.Module(body=[function_ast], type_ignores=[])
-        ast.fix_missing_locations(module_ast)
-
-        module_code = compile(module_ast, "<not_a_file>", "exec")
-        function_code = [c for c in module_code.co_consts if isinstance(c, CodeType)][0]
-
-        return FunctionType(
-            function_code, globals={"__builtins__": {"len": len, **self.convertors}}
-        )


Test patch:
diff --git a/docs_src/dependency_testing/tutorial001.py b/docs_src/dependency_testing/tutorial001.py
deleted file mode 100644
index e46585e..0000000
--- a/docs_src/dependency_testing/tutorial001.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from typing import Optional
-
-from squall import Depends, Squall
-from squall.testclient import TestClient
-
-app = Squall()
-
-
-async def common_parameters(q: Optional[str] = None, skip: int = 0, limit: int = 100):
-    return {"q": q, "skip": skip, "limit": limit}
-
-
-@app.get("/items/")
-async def read_items(commons: dict = Depends(common_parameters)):
-    return {"message": "Hello Items!", "params": commons}
-
-
-@app.get("/users/")
-async def read_users(commons: dict = Depends(common_parameters)):
-    return {"message": "Hello Users!", "params": commons}
-
-
-client = TestClient(app)
-
-
-async def override_dependency(q: Optional[str] = None):
-    return {"q": q, "skip": 5, "limit": 10}
-
-
-app.dependency_overrides[common_parameters] = override_dependency
-
-
-def test_override_in_items():
-    response = client.get("/items/")
-    assert response.status_code == 200
-    assert response.json() == {
-        "message": "Hello Items!",
-        "params": {"q": None, "skip": 5, "limit": 10},
-    }
-
-
-def test_override_in_items_with_q():
-    response = client.get("/items/?q=foo")
-    assert response.status_code == 200
-    assert response.json() == {
-        "message": "Hello Items!",
-        "params": {"q": "foo", "skip": 5, "limit": 10},
-    }
-
-
-def test_override_in_items_with_params():
-    response = client.get("/items/?q=foo&skip=100&limit=200")
-    assert response.status_code == 200
-    assert response.json() == {
-        "message": "Hello Items!",
-        "params": {"q": "foo", "skip": 5, "limit": 10},
-    }
diff --git a/docs_src/settings/app02/test_main.py b/docs_src/settings/app02/test_main.py
index 68e1605..6dc8d5e 100644
--- a/docs_src/settings/app02/test_main.py
+++ b/docs_src/settings/app02/test_main.py
@@ -1,23 +1,23 @@
-from squall.testclient import TestClient
-
-from .config import Settings
-from .main import app, get_settings
-
-client = TestClient(app)
-
-
-def get_settings_override():
-    return Settings(admin_email="testing_admin@example.com")
-
-
-app.dependency_overrides[get_settings] = get_settings_override
-
-
-def test_app():
-    response = client.get("/info")
-    data = response.json()
-    assert data == {
-        "app_name": "Awesome API",
-        "admin_email": "testing_admin@example.com",
-        "items_per_user": 50,
-    }
+# from squall.testclient import TestClient
+#
+# from .config import Settings
+# from .main import app, get_settings
+#
+# client = TestClient(app)
+#
+#
+# def get_settings_override():
+#     return Settings(admin_email="testing_admin@example.com")
+#
+#
+# app.dependency_overrides[get_settings] = get_settings_override
+#
+#
+# def test_app():
+#     response = client.get("/info")
+#     data = response.json()
+#     assert data == {
+#         "app_name": "Awesome API",
+#         "admin_email": "testing_admin@example.com",
+#         "items_per_user": 50,
+#     }
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..cf0dfd4
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,13 @@
+import pytest
+from squall import Squall
+from squall.testclient import TestClient
+
+
+@pytest.fixture(scope="function")
+def app():
+    return Squall()
+
+
+@pytest.fixture(scope="function")
+def client(app):
+    return TestClient(app)
diff --git a/tests/main.py b/tests/main.py
index 5553fd1..d51e28d 100644
--- a/tests/main.py
+++ b/tests/main.py
@@ -43,11 +43,6 @@ def get_float_id(item_id: float):
     return item_id
 
 
-@app.get("/path/bool/{item_id}")
-def get_bool_id(item_id: bool):
-    return item_id
-
-
 @app.get("/path/param/{item_id}")
 def get_path_param_id(item_id: Optional[str] = Path(None)):
     return item_id
diff --git a/tests/test_callable_endpoint.py b/tests/test_callable_endpoint.py
deleted file mode 100644
index 75f87db..0000000
--- a/tests/test_callable_endpoint.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from functools import partial
-from typing import Optional
-
-from squall import Squall
-from squall.testclient import TestClient
-
-
-def main(some_arg, q: Optional[str] = None):
-    return {"some_arg": some_arg, "q": q}
-
-
-endpoint = partial(main, "foo")
-
-app = Squall()
-
-app.get("/")(endpoint)
-
-
-client = TestClient(app)
-
-
-def test_partial():
-    response = client.get("/?q=bar")
-    data = response.json()
-    assert data == {"some_arg": "foo", "q": "bar"}
diff --git a/tests/test_default_response_class_router.py b/tests/test_default_response_class_router.py
index 4f47053..a8a3ce8 100644
--- a/tests/test_default_response_class_router.py
+++ b/tests/test_default_response_class_router.py
@@ -7,202 +7,80 @@ class OverrideResponse(JSONResponse):
     media_type = "application/x-override"
 
 
-app = Squall()
-router_a = Router(prefix="/a")
-router_a_a = Router(prefix="/a")
-router_a_b_override = Router(
-    prefix="/b", default_response_class=PlainTextResponse
-)  # Overrides default class
-router_b_override = Router(
-    prefix="/b", default_response_class=PlainTextResponse
-)  # Overrides default class
-router_b_a = Router(prefix="/a")
-router_b_a_c_override = Router(
-    prefix="/c", default_response_class=HTMLResponse
-)  # Overrides default class again
-
-
-@app.get("/")
-def get_root():
-    return {"msg": "Hello World"}
-
-
-@app.get("/override", response_class=PlainTextResponse)
-def get_path_override():
-    return "Hello World"
-
-
-@router_a.get("/")
-def get_a():
-    return {"msg": "Hello A"}
-
-
-@router_a.get("/override", response_class=PlainTextResponse)
-def get_a_path_override():
-    return "Hello A"
-
-
-@router_a_a.get("/")
-def get_a_a():
-    return {"msg": "Hello A A"}
-
-
-@router_a_a.get("/override", response_class=PlainTextResponse)
-def get_a_a_path_override():
-    return "Hello A A"
-
-
-@router_a_b_override.get("/")
-def get_a_b():
-    return "Hello A B"
-
-
-@router_a_b_override.get("/override", response_class=HTMLResponse)
-def get_a_b_path_override():
-    return "Hello A B"
-
-
-@router_b_override.get("/")
-def get_b():
-    return "Hello B"
-
-
-@router_b_override.get("/override", response_class=HTMLResponse)
-def get_b_path_override():
-    return "Hello B"
-
-
-@router_b_a.get("/", response_class=PlainTextResponse)
-def get_b_a():
-    return "Hello B A"
-
-
-@router_b_a.get("/override", response_class=HTMLResponse)
-def get_b_a_path_override():
-    return "Hello B A"
-
-
-@router_b_a_c_override.get("/")
-def get_b_a_c():
-    return "Hello B A C"
-
-
-@router_b_a_c_override.get("/override", response_class=OverrideResponse)
-def get_b_a_c_path_override():
-    return {"msg": "Hello B A C"}
-
-
-router_b_a.include_router(
-    router_b_a_c_override,
-)
-router_b_override.include_router(router_b_a)
-router_a.include_router(router_a_a)
-router_a.include_router(router_a_b_override)
-app.include_router(router_a)
-app.include_router(router_b_override)
-
-
-client = TestClient(app)
-
 json_type = "application/json"
 text_type = "text/plain; charset=utf-8"
 html_type = "text/html; charset=utf-8"
 override_type = "application/x-override"
 
 
-def test_app():
-    with client:
-        response = client.get("/")
-    assert response.json() == {"msg": "Hello World"}
-    assert response.headers["content-type"] == json_type
-
-
-def test_app_override():
-    with client:
-        response = client.get("/override")
-    assert response.content == b"Hello World"
-    assert response.headers["content-type"] == text_type
+def test_defaults():
+    app = Squall()
+    router = Router(prefix="/r")
 
+    @router.get("/")
+    def get_root():
+        return {"msg": "Hello World"}
 
-def test_router_a():
-    with client:
-        response = client.get("/a")
-    assert response.json() == {"msg": "Hello A"}
+    app.include_router(router)
+    client = TestClient(app)
+    response = client.get("/r")
+    assert response.json() == {"msg": "Hello World"}
     assert response.headers["content-type"] == json_type
 
 
-def test_router_a_override():
-    with client:
-        response = client.get("/a/override")
-    assert response.content == b"Hello A"
-    assert response.headers["content-type"] == text_type
+def test_override():
+    app = Squall()
+    router = Router(prefix="/r", default_response_class=OverrideResponse)
 
+    @router.get("/override")
+    def get_default():
+        return {"msg": "Hello World"}
 
-def test_router_a_a():
-    with client:
-        response = client.get("/a/a")
-    assert response.json() == {"msg": "Hello A A"}
-    assert response.headers["content-type"] == json_type
-
+    @router.get("/text", response_class=PlainTextResponse)
+    def get_overridden():
+        return "Hello World"
 
-def test_router_a_a_override():
-    with client:
-        response = client.get("/a/a/override")
-    assert response.content == b"Hello A A"
-    assert response.headers["content-type"] == text_type
+    app.include_router(router)
+    client = TestClient(app)
 
+    response = client.get("/r/override")
+    assert response.json() == {"msg": "Hello World"}
+    assert response.headers["content-type"] == override_type
 
-def test_router_a_b():
-    with client:
-        response = client.get("/a/b")
-    assert response.content == b"Hello A B"
+    response = client.get("/r/text")
+    assert response.text == "Hello World"
     assert response.headers["content-type"] == text_type
 
 
-def test_router_a_b_override():
-    with client:
-        response = client.get("/a/b/override")
-    assert response.content == b"Hello A B"
-    assert response.headers["content-type"] == html_type
+def test_nesting():
+    app = Squall()
+    router = Router(prefix="/r", default_response_class=OverrideResponse)
+    nested_router = Router(prefix="/n", default_response_class=HTMLResponse)
 
+    @nested_router.get("/html")
+    def get_default():
+        return "Hello HTML"
 
-def test_router_b():
-    with client:
-        response = client.get("/b")
-    assert response.content == b"Hello B"
-    assert response.headers["content-type"] == text_type
+    @router.get("/override")
+    def get_default():
+        return {"msg": "Hello World"}
 
+    @router.get("/text", response_class=PlainTextResponse)
+    def get_overridden():
+        return "Hello World"
 
-def test_router_b_override():
-    with client:
-        response = client.get("/b/override")
-    assert response.content == b"Hello B"
-    assert response.headers["content-type"] == html_type
+    router.include_router(nested_router)
+    app.include_router(router)
+    client = TestClient(app)
 
+    response = client.get("/r/override")
+    assert response.json() == {"msg": "Hello World"}
+    assert response.headers["content-type"] == override_type
 
-def test_router_b_a():
-    with client:
-        response = client.get("/b/a")
-    assert response.content == b"Hello B A"
+    response = client.get("/r/text")
+    assert response.text == "Hello World"
     assert response.headers["content-type"] == text_type
 
-
-def test_router_b_a_override():
-    with client:
-        response = client.get("/b/a/override")
-    assert response.content == b"Hello B A"
-    assert response.headers["content-type"] == html_type
-
-
-def test_router_b_a_c():
-    with client:
-        response = client.get("/b/a/c")
-    assert response.content == b"Hello B A C"
+    response = client.get("/r/n/html")
+    assert response.text == "Hello HTML"
     assert response.headers["content-type"] == html_type
-
-
-def test_router_b_a_c_override():
-    with client:
-        response = client.get("/b/a/c/override")
-    assert response.json() == {"msg": "Hello B A C"}
-    assert response.headers["content-type"] == override_type
diff --git a/tests/test_dependency_cache.py b/tests/test_dependency_cache.py
deleted file mode 100644
index 9ba44d3..0000000
--- a/tests/test_dependency_cache.py
+++ /dev/null
@@ -1,68 +0,0 @@
-from squall import Depends, Squall
-from squall.testclient import TestClient
-
-app = Squall()
-
-counter_holder = {"counter": 0}
-
-
-async def dep_counter():
-    counter_holder["counter"] += 1
-    return counter_holder["counter"]
-
-
-async def super_dep(count: int = Depends(dep_counter)):
-    return count
-
-
-@app.get("/counter/")
-async def get_counter(count: int = Depends(dep_counter)):
-    return {"counter": count}
-
-
-@app.get("/sub-counter/")
-async def get_sub_counter(
-    subcount: int = Depends(super_dep), count: int = Depends(dep_counter)
-):
-    return {"counter": count, "subcounter": subcount}
-
-
-@app.get("/sub-counter-no-cache/")
-async def get_sub_counter_no_cache(
-    subcount: int = Depends(super_dep),
-    count: int = Depends(dep_counter, use_cache=False),
-):
-    return {"counter": count, "subcounter": subcount}
-
-
-client = TestClient(app)
-
-
-def test_normal_counter():
-    counter_holder["counter"] = 0
-    response = client.get("/counter/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"counter": 1}
-    response = client.get("/counter/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"counter": 2}
-
-
-def test_sub_counter():
-    counter_holder["counter"] = 0
-    response = client.get("/sub-counter/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"counter": 1, "subcounter": 1}
-    response = client.get("/sub-counter/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"counter": 2, "subcounter": 2}
-
-
-def test_sub_counter_no_cache():
-    counter_holder["counter"] = 0
-    response = client.get("/sub-counter-no-cache/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"counter": 2, "subcounter": 1}
-    response = client.get("/sub-counter-no-cache/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"counter": 4, "subcounter": 3}
diff --git a/tests/test_dependency_class.py b/tests/test_dependency_class.py
deleted file mode 100644
index fd83eac..0000000
--- a/tests/test_dependency_class.py
+++ /dev/null
@@ -1,122 +0,0 @@
-from typing import AsyncGenerator, Generator
-
-import pytest
-from squall import Depends, Squall
-from squall.testclient import TestClient
-
-app = Squall()
-
-
-class CallableDependency:
-    def __call__(self, value: str) -> str:
-        return value
-
-
-class CallableGenDependency:
-    def __call__(self, value: str) -> Generator[str, None, None]:
-        yield value
-
-
-class AsyncCallableDependency:
-    async def __call__(self, value: str) -> str:
-        return value
-
-
-class AsyncCallableGenDependency:
-    async def __call__(self, value: str) -> AsyncGenerator[str, None]:
-        yield value
-
-
-class MethodsDependency:
-    def synchronous(self, value: str) -> str:
-        return value
-
-    async def asynchronous(self, value: str) -> str:
-        return value
-
-    def synchronous_gen(self, value: str) -> Generator[str, None, None]:
-        yield value
-
-    async def asynchronous_gen(self, value: str) -> AsyncGenerator[str, None]:
-        yield value
-
-
-callable_dependency = CallableDependency()
-callable_gen_dependency = CallableGenDependency()
-async_callable_dependency = AsyncCallableDependency()
-async_callable_gen_dependency = AsyncCallableGenDependency()
-methods_dependency = MethodsDependency()
-
-
-@app.get("/callable-dependency")
-async def get_callable_dependency(value: str = Depends(callable_dependency)):
-    return value
-
-
-@app.get("/callable-gen-dependency")
-async def get_callable_gen_dependency(value: str = Depends(callable_gen_dependency)):
-    return value
-
-
-@app.get("/async-callable-dependency")
-async def get_async_callable_dependency(
-    value: str = Depends(async_callable_dependency),
-):
-    return value
-
-
-@app.get("/async-callable-gen-dependency")
-async def get_async_callable_gen_dependency(
-    value: str = Depends(async_callable_gen_dependency),
-):
-    return value
-
-
-@app.get("/synchronous-method-dependency")
-async def get_synchronous_method_dependency(
-    value: str = Depends(methods_dependency.synchronous),
-):
-    return value
-
-
-@app.get("/synchronous-method-gen-dependency")
-async def get_synchronous_method_gen_dependency(
-    value: str = Depends(methods_dependency.synchronous_gen),
-):
-    return value
-
-
-@app.get("/asynchronous-method-dependency")
-async def get_asynchronous_method_dependency(
-    value: str = Depends(methods_dependency.asynchronous),
-):
-    return value
-
-
-@app.get("/asynchronous-method-gen-dependency")
-async def get_asynchronous_method_gen_dependency(
-    value: str = Depends(methods_dependency.asynchronous_gen),
-):
-    return value
-
-
-client = TestClient(app)
-
-
-@pytest.mark.parametrize(
-    "route,value",
-    [
-        ("/callable-dependency", "callable-dependency"),
-        ("/callable-gen-dependency", "callable-gen-dependency"),
-        ("/async-callable-dependency", "async-callable-dependency"),
-        ("/async-callable-gen-dependency", "async-callable-gen-dependency"),
-        ("/synchronous-method-dependency", "synchronous-method-dependency"),
-        ("/synchronous-method-gen-dependency", "synchronous-method-gen-dependency"),
-        ("/asynchronous-method-dependency", "asynchronous-method-dependency"),
-        ("/asynchronous-method-gen-dependency", "asynchronous-method-gen-dependency"),
-    ],
-)
-def test_class_dependency(route, value):
-    response = client.get(route, params={"value": value})
-    assert response.status_code == 200, response.text
-    assert response.json() == value
diff --git a/tests/test_dependency_contextmanager.py b/tests/test_dependency_contextmanager.py
deleted file mode 100644
index fb64695..0000000
--- a/tests/test_dependency_contextmanager.py
+++ /dev/null
@@ -1,349 +0,0 @@
-from typing import Dict
-
-import pytest
-from squall import BackgroundTasks, Depends, Squall
-from squall.testclient import TestClient
-
-app = Squall()
-state = {
-    "/async": "asyncgen not started",
-    "/sync": "generator not started",
-    "/async_raise": "asyncgen raise not started",
-    "/sync_raise": "generator raise not started",
-    "context_a": "not started a",
-    "context_b": "not started b",
-    "bg": "not set",
-    "sync_bg": "not set",
-}
-
-errors = []
-
-
-async def get_state():
-    return state
-
-
-class AsyncDependencyError(Exception):
-    pass
-
-
-class SyncDependencyError(Exception):
-    pass
-
-
-class OtherDependencyError(Exception):
-    pass
-
-
-async def asyncgen_state(state: Dict[str, str] = Depends(get_state)):
-    state["/async"] = "asyncgen started"
-    yield state["/async"]
-    state["/async"] = "asyncgen completed"
-
-
-def generator_state(state: Dict[str, str] = Depends(get_state)):
-    state["/sync"] = "generator started"
-    yield state["/sync"]
-    state["/sync"] = "generator completed"
-
-
-async def asyncgen_state_try(state: Dict[str, str] = Depends(get_state)):
-    state["/async_raise"] = "asyncgen raise started"
-    try:
-        yield state["/async_raise"]
-    except AsyncDependencyError:
-        errors.append("/async_raise")
-    finally:
-        state["/async_raise"] = "asyncgen raise finalized"
-
-
-def generator_state_try(state: Dict[str, str] = Depends(get_state)):
-    state["/sync_raise"] = "generator raise started"
-    try:
-        yield state["/sync_raise"]
-    except SyncDependencyError:
-        errors.append("/sync_raise")
-    finally:
-        state["/sync_raise"] = "generator raise finalized"
-
-
-async def context_a(state: dict = Depends(get_state)):
-    state["context_a"] = "started a"
-    try:
-        yield state
-    finally:
-        state["context_a"] = "finished a"
-
-
-async def context_b(state: dict = Depends(context_a)):
-    state["context_b"] = "started b"
-    try:
-        yield state
-    finally:
-        state["context_b"] = f"finished b with a: {state['context_a']}"
-
-
-@app.get("/async")
-async def get_async(state: str = Depends(asyncgen_state)):
-    return state
-
-
-@app.get("/sync")
-async def get_sync(state: str = Depends(generator_state)):
-    return state
-
-
-@app.get("/async_raise")
-async def get_async_raise(state: str = Depends(asyncgen_state_try)):
-    assert state == "asyncgen raise started"
-    raise AsyncDependencyError()
-
-
-@app.get("/sync_raise")
-async def get_sync_raise(state: str = Depends(generator_state_try)):
-    assert state == "generator raise started"
-    raise SyncDependencyError()
-
-
-@app.get("/async_raise_other")
-async def get_async_raise_other(state: str = Depends(asyncgen_state_try)):
-    assert state == "asyncgen raise started"
-    raise OtherDependencyError()
-
-
-@app.get("/sync_raise_other")
-async def get_sync_raise_other(state: str = Depends(generator_state_try)):
-    assert state == "generator raise started"
-    raise OtherDependencyError()
-
-
-@app.get("/context_b")
-async def get_context_b(state: dict = Depends(context_b)):
-    return state
-
-
-@app.get("/context_b_raise")
-async def get_context_b_raise(state: dict = Depends(context_b)):
-    assert state["context_b"] == "started b"
-    assert state["context_a"] == "started a"
-    raise OtherDependencyError()
-
-
-@app.get("/context_b_bg")
-async def get_context_b_bg(tasks: BackgroundTasks, state: dict = Depends(context_b)):
-    async def bg(state: dict):
-        state["bg"] = f"bg set - b: {state['context_b']} - a: {state['context_a']}"
-
-    tasks.add_task(bg, state)
-    return state
-
-
-# Sync versions
-
-
-@app.get("/sync_async")
-def get_sync_async(state: str = Depends(asyncgen_state)):
-    return state
-
-
-@app.get("/sync_sync")
-def get_sync_sync(state: str = Depends(generator_state)):
-    return state
-
-
-@app.get("/sync_async_raise")
-def get_sync_async_raise(state: str = Depends(asyncgen_state_try)):
-    assert state == "asyncgen raise started"
-    raise AsyncDependencyError()
-
-
-@app.get("/sync_sync_raise")
-def get_sync_sync_raise(state: str = Depends(generator_state_try)):
-    assert state == "generator raise started"
-    raise SyncDependencyError()
-
-
-@app.get("/sync_async_raise_other")
-def get_sync_async_raise_other(state: str = Depends(asyncgen_state_try)):
-    assert state == "asyncgen raise started"
-    raise OtherDependencyError()
-
-
-@app.get("/sync_sync_raise_other")
-def get_sync_sync_raise_other(state: str = Depends(generator_state_try)):
-    assert state == "generator raise started"
-    raise OtherDependencyError()
-
-
-@app.get("/sync_context_b")
-def get_sync_context_b(state: dict = Depends(context_b)):
-    return state
-
-
-@app.get("/sync_context_b_raise")
-def get_sync_context_b_raise(state: dict = Depends(context_b)):
-    assert state["context_b"] == "started b"
-    assert state["context_a"] == "started a"
-    raise OtherDependencyError()
-
-
-@app.get("/sync_context_b_bg")
-async def get_sync_context_b_bg(
-    tasks: BackgroundTasks, state: dict = Depends(context_b)
-):
-    async def bg(state: dict):
-        state[
-            "sync_bg"
-        ] = f"sync_bg set - b: {state['context_b']} - a: {state['context_a']}"
-
-    tasks.add_task(bg, state)
-    return state
-
-
-client = TestClient(app)
-
-
-def test_async_state():
-    assert state["/async"] == "asyncgen not started"
-    response = client.get("/async")
-    assert response.status_code == 200, response.text
-    assert response.json() == "asyncgen started"
-    assert state["/async"] == "asyncgen completed"
-
-
-def test_sync_state():
-    assert state["/sync"] == "generator not started"
-    response = client.get("/sync")
-    assert response.status_code == 200, response.text
-    assert response.json() == "generator started"
-    assert state["/sync"] == "generator completed"
-
-
-def test_async_raise_other():
-    assert state["/async_raise"] == "asyncgen raise not started"
-    with pytest.raises(OtherDependencyError):
-        client.get("/async_raise_other")
-    assert state["/async_raise"] == "asyncgen raise finalized"
-    assert "/async_raise" not in errors
-
-
-def test_sync_raise_other():
-    assert state["/sync_raise"] == "generator raise not started"
-    with pytest.raises(OtherDependencyError):
-        client.get("/sync_raise_other")
-    assert state["/sync_raise"] == "generator raise finalized"
-    assert "/sync_raise" not in errors
-
-
-def test_async_raise():
-    response = client.get("/async_raise")
-    assert response.status_code == 500, response.text
-    assert state["/async_raise"] == "asyncgen raise finalized"
-    assert "/async_raise" in errors
-    errors.clear()
-
-
-def test_context_b():
-    response = client.get("/context_b")
-    data = response.json()
-    assert data["context_b"] == "started b"
-    assert data["context_a"] == "started a"
-    assert state["context_b"] == "finished b with a: started a"
-    assert state["context_a"] == "finished a"
-
-
-def test_context_b_raise():
-    with pytest.raises(OtherDependencyError):
-        client.get("/context_b_raise")
-    assert state["context_b"] == "finished b with a: started a"
-    assert state["context_a"] == "finished a"
-
-
-def test_background_tasks():
-    response = client.get("/context_b_bg")
-    data = response.json()
-    assert data["context_b"] == "started b"
-    assert data["context_a"] == "started a"
-    assert data["bg"] == "not set"
-    assert state["context_b"] == "finished b with a: started a"
-    assert state["context_a"] == "finished a"
-    assert state["bg"] == "bg set - b: started b - a: started a"
-
-
-def test_sync_raise():
-    response = client.get("/sync_raise")
-    assert response.status_code == 500, response.text
-    assert state["/sync_raise"] == "generator raise finalized"
-    assert "/sync_raise" in errors
-    errors.clear()
-
-
-def test_sync_async_state():
-    response = client.get("/sync_async")
-    assert response.status_code == 200, response.text
-    assert response.json() == "asyncgen started"
-    assert state["/async"] == "asyncgen completed"
-
-
-def test_sync_sync_state():
-    response = client.get("/sync_sync")
-    assert response.status_code == 200, response.text
-    assert response.json() == "generator started"
-    assert state["/sync"] == "generator completed"
-
-
-def test_sync_async_raise_other():
-    with pytest.raises(OtherDependencyError):
-        client.get("/sync_async_raise_other")
-    assert state["/async_raise"] == "asyncgen raise finalized"
-    assert "/async_raise" not in errors
-
-
-def test_sync_sync_raise_other():
-    with pytest.raises(OtherDependencyError):
-        client.get("/sync_sync_raise_other")
-    assert state["/sync_raise"] == "generator raise finalized"
-    assert "/sync_raise" not in errors
-
-
-def test_sync_async_raise():
-    response = client.get("/sync_async_raise")
-    assert response.status_code == 500, response.text
-    assert state["/async_raise"] == "asyncgen raise finalized"
-    assert "/async_raise" in errors
-    errors.clear()
-
-
-def test_sync_sync_raise():
-    response = client.get("/sync_sync_raise")
-    assert response.status_code == 500, response.text
-    assert state["/sync_raise"] == "generator raise finalized"
-    assert "/sync_raise" in errors
-    errors.clear()
-
-
-def test_sync_context_b():
-    response = client.get("/sync_context_b")
-    data = response.json()
-    assert data["context_b"] == "started b"
-    assert data["context_a"] == "started a"
-    assert state["context_b"] == "finished b with a: started a"
-    assert state["context_a"] == "finished a"
-
-
-def test_sync_context_b_raise():
-    with pytest.raises(OtherDependencyError):
-        client.get("/sync_context_b_raise")
-    assert state["context_b"] == "finished b with a: started a"
-    assert state["context_a"] == "finished a"
-
-
-def test_sync_background_tasks():
-    response = client.get("/sync_context_b_bg")
-    data = response.json()
-    assert data["context_b"] == "started b"
-    assert data["context_a"] == "started a"
-    assert data["sync_bg"] == "not set"
-    assert state["context_b"] == "finished b with a: started a"
-    assert state["context_a"] == "finished a"
-    assert state["sync_bg"] == "sync_bg set - b: started b - a: started a"
diff --git a/tests/test_dependency_duplicates.py b/tests/test_dependency_duplicates.py
deleted file mode 100644
index f1e85b5..0000000
--- a/tests/test_dependency_duplicates.py
+++ /dev/null
@@ -1,233 +0,0 @@
-from typing import List
-
-from pydantic import Field, dataclasses
-from squall import Depends, Squall
-from squall.testclient import TestClient
-
-app = Squall()
-
-client = TestClient(app)
-
-
-@dataclasses.dataclass
-class Item:
-    data: str = Field(...)
-
-
-def duplicate_dependency(item: Item):
-    return item
-
-
-def dependency(item2: Item):
-    return item2
-
-
-def sub_duplicate_dependency(
-    item: Item, sub_item: Item = Depends(duplicate_dependency)
-):
-    return [item, sub_item]
-
-
-@app.post("/with-duplicates")
-async def with_duplicates(item: Item, item2: Item = Depends(duplicate_dependency)):
-    return [item, item2]
-
-
-@app.post("/no-duplicates")
-async def no_duplicates(item: Item, item2: Item = Depends(dependency)):
-    return [item, item2]
-
-
-@app.post("/with-duplicates-sub")
-async def no_duplicates_sub(
-    item: Item, sub_items: List[Item] = Depends(sub_duplicate_dependency)
-):
-    return [item, sub_items]
-
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/with-duplicates": {
-            "post": {
-                "summary": "With Duplicates",
-                "operationId": "with_duplicates_with_duplicates_post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/Item"}
-                        }
-                    },
-                    "required": True,
-                },
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-        "/no-duplicates": {
-            "post": {
-                "summary": "No Duplicates",
-                "operationId": "no_duplicates_no_duplicates_post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {
-                                "$ref": "#/components/schemas/Body_no_duplicates_no_duplicates_post"
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-        "/with-duplicates-sub": {
-            "post": {
-                "summary": "No Duplicates Sub",
-                "operationId": "no_duplicates_sub_with_duplicates_sub_post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/Item"}
-                        }
-                    },
-                    "required": True,
-                },
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-    },
-    "components": {
-        "schemas": {
-            "Body_no_duplicates_no_duplicates_post": {
-                "title": "Body_no_duplicates_no_duplicates_post",
-                "required": ["item", "item2"],
-                "type": "object",
-                "properties": {
-                    "item": {"$ref": "#/components/schemas/Item"},
-                    "item2": {"$ref": "#/components/schemas/Item"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-            "Item": {
-                "title": "Item",
-                "required": ["data"],
-                "type": "object",
-                "properties": {"data": {"title": "Data", "type": "string"}},
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_no_duplicates_invalid():
-    response = client.post("/no-duplicates", json={"item": {"data": "myitem"}})
-    assert response.status_code == 422, response.text
-    assert response.json() == {
-        "detail": [
-            {
-                "loc": ["body", "item2"],
-                "msg": "field required",
-                "type": "value_error.missing",
-            }
-        ]
-    }
-
-
-def test_no_duplicates():
-    response = client.post(
-        "/no-duplicates",
-        json={"item": {"data": "myitem"}, "item2": {"data": "myitem2"}},
-    )
-    assert response.status_code == 200, response.text
-    assert response.json() == [{"data": "myitem"}, {"data": "myitem2"}]
-
-
-def test_duplicates():
-    response = client.post("/with-duplicates", json={"data": "myitem"})
-    assert response.status_code == 200, response.text
-    assert response.json() == [{"data": "myitem"}, {"data": "myitem"}]
-
-
-def test_sub_duplicates():
-    response = client.post("/with-duplicates-sub", json={"data": "myitem"})
-    assert response.status_code == 200, response.text
-    assert response.json() == [
-        {"data": "myitem"},
-        [{"data": "myitem"}, {"data": "myitem"}],
-    ]
diff --git a/tests/test_dependency_overrides.py b/tests/test_dependency_overrides.py
deleted file mode 100644
index 8579c7e..0000000
--- a/tests/test_dependency_overrides.py
+++ /dev/null
@@ -1,316 +0,0 @@
-# from typing import Optional
-#
-# import pytest
-# from squall import Depends, Squall
-# from squall.router import Router
-# from squall.testclient import TestClient
-#
-# app = Squall()
-#
-# router = Router()
-#
-#
-# async def common_parameters(q: str, skip: int = 0, limit: int = 100):
-#     return {"q": q, "skip": skip, "limit": limit}
-#
-#
-# @app.get("/main-depends/")
-# async def main_depends(commons: dict = Depends(common_parameters)):
-#     return {"in": "main-depends", "params": commons}
-#
-#
-# @app.get("/decorator-depends/", dependencies=[Depends(common_parameters)])
-# async def decorator_depends():
-#     return {"in": "decorator-depends"}
-#
-#
-# @router.get("/router-depends/")
-# async def router_depends(commons: dict = Depends(common_parameters)):
-#     return {"in": "router-depends", "params": commons}
-#
-#
-# @router.get("/router-decorator-depends/", dependencies=[Depends(common_parameters)])
-# async def router_decorator_depends():
-#     return {"in": "router-decorator-depends"}
-#
-#
-# app.include_router(router)
-#
-# client = TestClient(app)
-#
-#
-# async def overrider_dependency_simple(q: Optional[str] = None):
-#     return {"q": q, "skip": 5, "limit": 10}
-#
-#
-# async def overrider_sub_dependency(k: str):
-#     return {"k": k}
-#
-#
-# async def overrider_dependency_with_sub(msg: dict = Depends(overrider_sub_dependency)):
-#     return msg
-#
-#
-# @pytest.mark.parametrize(
-#     "url,status_code,expected",
-#     [
-#         (
-#             "/main-depends/",
-#             422,
-#             {
-#                 "detail": [
-#                     {
-#                         "loc": ["query", "q"],
-#                         "msg": "field required",
-#                         "type": "value_error.missing",
-#                     }
-#                 ]
-#             },
-#         ),
-#         (
-#             "/main-depends/?q=foo",
-#             200,
-#             {"in": "main-depends", "params": {"q": "foo", "skip": 0, "limit": 100}},
-#         ),
-#         (
-#             "/main-depends/?q=foo&skip=100&limit=200",
-#             200,
-#             {"in": "main-depends", "params": {"q": "foo", "skip": 100, "limit": 200}},
-#         ),
-#         (
-#             "/decorator-depends/",
-#             422,
-#             {
-#                 "detail": [
-#                     {
-#                         "loc": ["query", "q"],
-#                         "msg": "field required",
-#                         "type": "value_error.missing",
-#                     }
-#                 ]
-#             },
-#         ),
-#         ("/decorator-depends/?q=foo", 200, {"in": "decorator-depends"}),
-#         (
-#             "/decorator-depends/?q=foo&skip=100&limit=200",
-#             200,
-#             {"in": "decorator-depends"},
-#         ),
-#         (
-#             "/router-depends/",
-#             422,
-#             {
-#                 "detail": [
-#                     {
-#                         "loc": ["query", "q"],
-#                         "msg": "field required",
-#                         "type": "value_error.missing",
-#                     }
-#                 ]
-#             },
-#         ),
-#         (
-#             "/router-depends/?q=foo",
-#             200,
-#             {"in": "router-depends", "params": {"q": "foo", "skip": 0, "limit": 100}},
-#         ),
-#         (
-#             "/router-depends/?q=foo&skip=100&limit=200",
-#             200,
-#             {"in": "router-depends", "params": {"q": "foo", "skip": 100, "limit": 200}},
-#         ),
-#         (
-#             "/router-decorator-depends/",
-#             422,
-#             {
-#                 "detail": [
-#                     {
-#                         "loc": ["query", "q"],
-#                         "msg": "field required",
-#                         "type": "value_error.missing",
-#                     }
-#                 ]
-#             },
-#         ),
-#         ("/router-decorator-depends/?q=foo", 200, {"in": "router-decorator-depends"}),
-#         (
-#             "/router-decorator-depends/?q=foo&skip=100&limit=200",
-#             200,
-#             {"in": "router-decorator-depends"},
-#         ),
-#     ],
-# )
-# def test_normal_app(url, status_code, expected):
-#     response = client.get(url)
-#     assert response.status_code == status_code
-#     assert response.json() == expected
-#
-#
-# @pytest.mark.parametrize(
-#     "url,status_code,expected",
-#     [
-#         (
-#             "/main-depends/",
-#             200,
-#             {"in": "main-depends", "params": {"q": None, "skip": 5, "limit": 10}},
-#         ),
-#         (
-#             "/main-depends/?q=foo",
-#             200,
-#             {"in": "main-depends", "params": {"q": "foo", "skip": 5, "limit": 10}},
-#         ),
-#         (
-#             "/main-depends/?q=foo&skip=100&limit=200",
-#             200,
-#             {"in": "main-depends", "params": {"q": "foo", "skip": 5, "limit": 10}},
-#         ),
-#         ("/decorator-depends/", 200, {"in": "decorator-depends"}),
-#         (
-#             "/router-depends/",
-#             200,
-#             {"in": "router-depends", "params": {"q": None, "skip": 5, "limit": 10}},
-#         ),
-#         (
-#             "/router-depends/?q=foo",
-#             200,
-#             {"in": "router-depends", "params": {"q": "foo", "skip": 5, "limit": 10}},
-#         ),
-#         (
-#             "/router-depends/?q=foo&skip=100&limit=200",
-#             200,
-#             {"in": "router-depends", "params": {"q": "foo", "skip": 5, "limit": 10}},
-#         ),
-#         ("/router-decorator-depends/", 200, {"in": "router-decorator-depends"}),
-#     ],
-# )
-# def test_override_simple(url, status_code, expected):
-#     app.dependency_overrides[common_parameters] = overrider_dependency_simple
-#     response = client.get(url)
-#     assert response.status_code == status_code
-#     assert response.json() == expected
-#     app.dependency_overrides = {}
-#
-#
-# @pytest.mark.parametrize(
-#     "url,status_code,expected",
-#     [
-#         (
-#             "/main-depends/",
-#             422,
-#             {
-#                 "detail": [
-#                     {
-#                         "loc": ["query", "k"],
-#                         "msg": "field required",
-#                         "type": "value_error.missing",
-#                     }
-#                 ]
-#             },
-#         ),
-#         (
-#             "/main-depends/?q=foo",
-#             422,
-#             {
-#                 "detail": [
-#                     {
-#                         "loc": ["query", "k"],
-#                         "msg": "field required",
-#                         "type": "value_error.missing",
-#                     }
-#                 ]
-#             },
-#         ),
-#         ("/main-depends/?k=bar", 200, {"in": "main-depends", "params": {"k": "bar"}}),
-#         (
-#             "/decorator-depends/",
-#             422,
-#             {
-#                 "detail": [
-#                     {
-#                         "loc": ["query", "k"],
-#                         "msg": "field required",
-#                         "type": "value_error.missing",
-#                     }
-#                 ]
-#             },
-#         ),
-#         (
-#             "/decorator-depends/?q=foo",
-#             422,
-#             {
-#                 "detail": [
-#                     {
-#                         "loc": ["query", "k"],
-#                         "msg": "field required",
-#                         "type": "value_error.missing",
-#                     }
-#                 ]
-#             },
-#         ),
-#         ("/decorator-depends/?k=bar", 200, {"in": "decorator-depends"}),
-#         (
-#             "/router-depends/",
-#             422,
-#             {
-#                 "detail": [
-#                     {
-#                         "loc": ["query", "k"],
-#                         "msg": "field required",
-#                         "type": "value_error.missing",
-#                     }
-#                 ]
-#             },
-#         ),
-#         (
-#             "/router-depends/?q=foo",
-#             422,
-#             {
-#                 "detail": [
-#                     {
-#                         "loc": ["query", "k"],
-#                         "msg": "field required",
-#                         "type": "value_error.missing",
-#                     }
-#                 ]
-#             },
-#         ),
-#         (
-#             "/router-depends/?k=bar",
-#             200,
-#             {"in": "router-depends", "params": {"k": "bar"}},
-#         ),
-#         (
-#             "/router-decorator-depends/",
-#             422,
-#             {
-#                 "detail": [
-#                     {
-#                         "loc": ["query", "k"],
-#                         "msg": "field required",
-#                         "type": "value_error.missing",
-#                     }
-#                 ]
-#             },
-#         ),
-#         (
-#             "/router-decorator-depends/?q=foo",
-#             422,
-#             {
-#                 "detail": [
-#                     {
-#                         "loc": ["query", "k"],
-#                         "msg": "field required",
-#                         "type": "value_error.missing",
-#                     }
-#                 ]
-#             },
-#         ),
-#         ("/router-decorator-depends/?k=bar", 200, {"in": "router-decorator-depends"}),
-#     ],
-# )
-# def test_override_with_sub(url, status_code, expected):
-#     app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
-#     response = client.get(url)
-#     assert response.status_code == status_code
-#     assert response.json() == expected
-#     app.dependency_overrides = {}
diff --git a/tests/test_dependency_security_overrides.py b/tests/test_dependency_security_overrides.py
deleted file mode 100644
index 3a4b55b..0000000
--- a/tests/test_dependency_security_overrides.py
+++ /dev/null
@@ -1,65 +0,0 @@
-from typing import List, Tuple
-
-from squall import Depends, Security, Squall
-from squall.security import SecurityScopes
-from squall.testclient import TestClient
-
-app = Squall()
-
-
-def get_user(required_scopes: SecurityScopes):
-    return "john", required_scopes.scopes
-
-
-def get_user_override(required_scopes: SecurityScopes):
-    return "alice", required_scopes.scopes
-
-
-def get_data():
-    return [1, 2, 3]
-
-
-def get_data_override():
-    return [3, 4, 5]
-
-
-@app.get("/user")
-def read_user(
-    user_data: Tuple[str, List[str]] = Security(get_user, scopes=["foo", "bar"]),
-    data: List[int] = Depends(get_data),
-):
-    return {"user": user_data[0], "scopes": user_data[1], "data": data}
-
-
-client = TestClient(app)
-
-
-def test_normal():
-    response = client.get("/user")
-    assert response.json() == {
-        "user": "john",
-        "scopes": ["foo", "bar"],
-        "data": [1, 2, 3],
-    }
-
-
-def test_override_data():
-    app.dependency_overrides[get_data] = get_data_override
-    response = client.get("/user")
-    assert response.json() == {
-        "user": "john",
-        "scopes": ["foo", "bar"],
-        "data": [3, 4, 5],
-    }
-    app.dependency_overrides = {}
-
-
-def test_override_security():
-    app.dependency_overrides[get_user] = get_user_override
-    response = client.get("/user")
-    assert response.json() == {
-        "user": "alice",
-        "scopes": ["foo", "bar"],
-        "data": [1, 2, 3],
-    }
-    app.dependency_overrides = {}
diff --git a/tests/test_exception_handlers.py b/tests/test_exception_handlers.py
index 11582f9..ca4f39f 100644
--- a/tests/test_exception_handlers.py
+++ b/tests/test_exception_handlers.py
@@ -1,5 +1,5 @@
 from squall import HTTPException, Squall
-from squall.exceptions import RequestValidationError
+from squall.exceptions import RequestPayloadValidationError
 from squall.testclient import TestClient
 from starlette.responses import JSONResponse
 
@@ -15,7 +15,7 @@ def request_validation_exception_handler(request, exception):
 app = Squall(
     exception_handlers={
         HTTPException: http_exception_handler,
-        RequestValidationError: request_validation_exception_handler,
+        RequestPayloadValidationError: request_validation_exception_handler,
     }
 )
 
diff --git a/tests/test_filter_pydantic_sub_model.py b/tests/test_filter_pydantic_sub_model.py
index 527141d..e0a084f 100644
--- a/tests/test_filter_pydantic_sub_model.py
+++ b/tests/test_filter_pydantic_sub_model.py
@@ -1,159 +1,159 @@
-from typing import Optional
-
-import pytest
-from pydantic import Field, ValidationError, dataclasses, validator
-from squall import Depends, Squall
-from squall.testclient import TestClient
-
-app = Squall()
-
-
-@dataclasses.dataclass
-class ModelB:
-    username: str
-
-
-@dataclasses.dataclass
-class ModelC(ModelB):
-    password: str
-
-
-@dataclasses.dataclass
-class ModelA:
-    name: str = Field(...)
-    description: Optional[str] = None
-    model_b: ModelB = Field(...)
-
-    @validator("name")
-    def lower_username(cls, name: str, values):
-        if not name.endswith("A"):
-            raise ValueError("name must end in A")
-        return name
-
-
-async def get_model_c() -> ModelC:
-    return ModelC(username="test-user", password="test-password")
-
-
-@app.get("/model/{name}", response_model=ModelA)
-async def get_model_a(name: str, model_c=Depends(get_model_c)):
-    return {"name": name, "description": "model-a-desc", "model_b": model_c}
-
-
-client = TestClient(app)
-
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/model/{name}": {
-            "get": {
-                "summary": "Get Model A",
-                "operationId": "get_model_a_model__name__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Name", "type": "string"},
-                        "name": "name",
-                        "in": "path",
-                    }
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/ModelA"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-            "ModelA": {
-                "title": "ModelA",
-                "required": ["name", "model_b"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "description": {"title": "Description", "type": "string"},
-                    "model_b": {"$ref": "#/components/schemas/ModelB"},
-                },
-            },
-            "ModelB": {
-                "title": "ModelB",
-                "required": ["username"],
-                "type": "object",
-                "properties": {"username": {"title": "Username", "type": "string"}},
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_filter_sub_model():
-    response = client.get("/model/modelA")
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "name": "modelA",
-        "description": "model-a-desc",
-        "model_b": {"username": "test-user", "password": "test-password"},
-    }
-
-
-def test_validator_is_cloned():
-    with pytest.raises(ValidationError) as err:
-        client.get("/model/modelX")
-
-    assert err.value.errors() == [
-        {
-            "loc": ("response", "name"),
-            "msg": "name must end in A",
-            "type": "value_error",
-        }
-    ]
+# from typing import Optional
+#
+# import pytest
+# from pydantic import Field, ValidationError, dataclasses, validator
+# from squall import Depends, Squall
+# from squall.testclient import TestClient
+#
+# app = Squall()
+#
+#
+# @dataclasses.dataclass
+# class ModelB:
+#     username: str
+#
+#
+# @dataclasses.dataclass
+# class ModelC(ModelB):
+#     password: str
+#
+#
+# @dataclasses.dataclass
+# class ModelA:
+#     name: str = Field(...)
+#     description: Optional[str] = None
+#     model_b: ModelB = Field(...)
+#
+#     @validator("name")
+#     def lower_username(cls, name: str, values):
+#         if not name.endswith("A"):
+#             raise ValueError("name must end in A")
+#         return name
+#
+#
+# async def get_model_c() -> ModelC:
+#     return ModelC(username="test-user", password="test-password")
+#
+#
+# @app.get("/model/{name}", response_model=ModelA)
+# async def get_model_a(name: str, model_c=Depends(get_model_c)):
+#     return {"name": name, "description": "model-a-desc", "model_b": model_c}
+#
+#
+# client = TestClient(app)
+#
+#
+# openapi_schema = {
+#     "openapi": "3.0.2",
+#     "info": {"title": "Squall", "version": "0.1.0"},
+#     "paths": {
+#         "/model/{name}": {
+#             "get": {
+#                 "summary": "Get Model A",
+#                 "operationId": "get_model_a_model__name__get",
+#                 "parameters": [
+#                     {
+#                         "required": True,
+#                         "schema": {"title": "Name", "type": "string"},
+#                         "name": "name",
+#                         "in": "path",
+#                     }
+#                 ],
+#                 "responses": {
+#                     "200": {
+#                         "description": "Successful Response",
+#                         "content": {
+#                             "application/json": {
+#                                 "schema": {"$ref": "#/components/schemas/ModelA"}
+#                             }
+#                         },
+#                     },
+#                     "422": {
+#                         "description": "Validation Error",
+#                         "content": {
+#                             "application/json": {
+#                                 "schema": {
+#                                     "$ref": "#/components/schemas/HTTPValidationError"
+#                                 }
+#                             }
+#                         },
+#                     },
+#                 },
+#             }
+#         }
+#     },
+#     "components": {
+#         "schemas": {
+#             "HTTPValidationError": {
+#                 "title": "HTTPValidationError",
+#                 "type": "object",
+#                 "properties": {
+#                     "detail": {
+#                         "title": "Detail",
+#                         "type": "array",
+#                         "items": {"$ref": "#/components/schemas/ValidationError"},
+#                     }
+#                 },
+#             },
+#             "ModelA": {
+#                 "title": "ModelA",
+#                 "required": ["name", "model_b"],
+#                 "type": "object",
+#                 "properties": {
+#                     "name": {"title": "Name", "type": "string"},
+#                     "description": {"title": "Description", "type": "string"},
+#                     "model_b": {"$ref": "#/components/schemas/ModelB"},
+#                 },
+#             },
+#             "ModelB": {
+#                 "title": "ModelB",
+#                 "required": ["username"],
+#                 "type": "object",
+#                 "properties": {"username": {"title": "Username", "type": "string"}},
+#             },
+#             "ValidationError": {
+#                 "title": "ValidationError",
+#                 "required": ["loc", "msg", "type"],
+#                 "type": "object",
+#                 "properties": {
+#                     "loc": {
+#                         "title": "Location",
+#                         "type": "array",
+#                         "items": {"type": "string"},
+#                     },
+#                     "msg": {"title": "Message", "type": "string"},
+#                     "type": {"title": "Error Type", "type": "string"},
+#                 },
+#             },
+#         }
+#     },
+# }
+#
+#
+# def test_openapi_schema():
+#     response = client.get("/openapi.json")
+#     assert response.status_code == 200, response.text
+#     assert response.json() == openapi_schema
+#
+#
+# def test_filter_sub_model():
+#     response = client.get("/model/modelA")
+#     assert response.status_code == 200, response.text
+#     assert response.json() == {
+#         "name": "modelA",
+#         "description": "model-a-desc",
+#         "model_b": {"username": "test-user", "password": "test-password"},
+#     }
+#
+#
+# def test_validator_is_cloned():
+#     with pytest.raises(ValidationError) as err:
+#         client.get("/model/modelX")
+#
+#     assert err.value.errors() == [
+#         {
+#             "loc": ("response", "name"),
+#             "msg": "name must end in A",
+#             "type": "value_error",
+#         }
+#     ]
diff --git a/tests/test_http_connection_injection.py b/tests/test_http_connection_injection.py
deleted file mode 100644
index 0c5f78b..0000000
--- a/tests/test_http_connection_injection.py
+++ /dev/null
@@ -1,39 +0,0 @@
-from squall import Depends, Squall
-from squall.requests import HTTPConnection
-from squall.testclient import TestClient
-from starlette.websockets import WebSocket
-
-app = Squall()
-app.state.value = 42
-
-
-async def extract_value_from_http_connection(conn: HTTPConnection):
-    return conn.app.state.value
-
-
-@app.get("/http")
-async def get_value_by_http(value: int = Depends(extract_value_from_http_connection)):
-    return value
-
-
-@app.websocket("/ws")
-async def get_value_by_ws(
-    websocket: WebSocket, value: int = Depends(extract_value_from_http_connection)
-):
-    await websocket.accept()
-    await websocket.send_json(value)
-    await websocket.close()
-
-
-client = TestClient(app)
-
-
-def test_value_extracting_by_http():
-    response = client.get("/http")
-    assert response.status_code == 200
-    assert response.json() == 42
-
-
-def test_value_extracting_by_ws():
-    with client.websocket_connect("/ws") as websocket:
-        assert websocket.receive_json() == 42
diff --git a/tests/test_multipart_installation.py b/tests/test_multipart_installation.py
index 4130d42..6fc167f 100644
--- a/tests/test_multipart_installation.py
+++ b/tests/test_multipart_installation.py
@@ -1,106 +1,106 @@
-import pytest
-from squall import File, Form, Squall, UploadFile
-from squall.dependencies.utils import (
-    multipart_incorrect_install_error,
-    multipart_not_installed_error,
-)
-
-
-def test_incorrect_multipart_installed_form(monkeypatch):
-    monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)
-    with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):
-        app = Squall()
-
-        @app.post("/")
-        async def root(username: str = Form(...)):
-            return username  # pragma: nocover
-
-
-def test_incorrect_multipart_installed_file_upload(monkeypatch):
-    monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)
-    with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):
-        app = Squall()
-
-        @app.post("/")
-        async def root(f: UploadFile = File(...)):
-            return f  # pragma: nocover
-
-
-def test_incorrect_multipart_installed_file_bytes(monkeypatch):
-    monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)
-    with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):
-        app = Squall()
-
-        @app.post("/")
-        async def root(f: bytes = File(...)):
-            return f  # pragma: nocover
-
-
-def test_incorrect_multipart_installed_multi_form(monkeypatch):
-    monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)
-    with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):
-        app = Squall()
-
-        @app.post("/")
-        async def root(username: str = Form(...), password: str = Form(...)):
-            return username  # pragma: nocover
-
-
-def test_incorrect_multipart_installed_form_file(monkeypatch):
-    monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)
-    with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):
-        app = Squall()
-
-        @app.post("/")
-        async def root(username: str = Form(...), f: UploadFile = File(...)):
-            return username  # pragma: nocover
-
-
-def test_no_multipart_installed(monkeypatch):
-    monkeypatch.delattr("multipart.__version__", raising=False)
-    with pytest.raises(RuntimeError, match=multipart_not_installed_error):
-        app = Squall()
-
-        @app.post("/")
-        async def root(username: str = Form(...)):
-            return username  # pragma: nocover
-
-
-def test_no_multipart_installed_file(monkeypatch):
-    monkeypatch.delattr("multipart.__version__", raising=False)
-    with pytest.raises(RuntimeError, match=multipart_not_installed_error):
-        app = Squall()
-
-        @app.post("/")
-        async def root(f: UploadFile = File(...)):
-            return f  # pragma: nocover
-
-
-def test_no_multipart_installed_file_bytes(monkeypatch):
-    monkeypatch.delattr("multipart.__version__", raising=False)
-    with pytest.raises(RuntimeError, match=multipart_not_installed_error):
-        app = Squall()
-
-        @app.post("/")
-        async def root(f: bytes = File(...)):
-            return f  # pragma: nocover
-
-
-def test_no_multipart_installed_multi_form(monkeypatch):
-    monkeypatch.delattr("multipart.__version__", raising=False)
-    with pytest.raises(RuntimeError, match=multipart_not_installed_error):
-        app = Squall()
-
-        @app.post("/")
-        async def root(username: str = Form(...), password: str = Form(...)):
-            return username  # pragma: nocover
-
-
-def test_no_multipart_installed_form_file(monkeypatch):
-    monkeypatch.delattr("multipart.__version__", raising=False)
-    with pytest.raises(RuntimeError, match=multipart_not_installed_error):
-        app = Squall()
-
-        @app.post("/")
-        async def root(username: str = Form(...), f: UploadFile = File(...)):
-            return username  # pragma: nocover
+# import pytest
+# from squall import File, Form, Squall, UploadFile
+# from squall.dependencies.utils import (
+#     multipart_incorrect_install_error,
+#     multipart_not_installed_error,
+# )
+#
+#
+# def test_incorrect_multipart_installed_form(monkeypatch):
+#     monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)
+#     with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):
+#         app = Squall()
+#
+#         @app.post("/")
+#         async def root(username: str = Form(...)):
+#             return username  # pragma: nocover
+#
+#
+# def test_incorrect_multipart_installed_file_upload(monkeypatch):
+#     monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)
+#     with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):
+#         app = Squall()
+#
+#         @app.post("/")
+#         async def root(f: UploadFile = File(...)):
+#             return f  # pragma: nocover
+#
+#
+# def test_incorrect_multipart_installed_file_bytes(monkeypatch):
+#     monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)
+#     with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):
+#         app = Squall()
+#
+#         @app.post("/")
+#         async def root(f: bytes = File(...)):
+#             return f  # pragma: nocover
+#
+#
+# def test_incorrect_multipart_installed_multi_form(monkeypatch):
+#     monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)
+#     with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):
+#         app = Squall()
+#
+#         @app.post("/")
+#         async def root(username: str = Form(...), password: str = Form(...)):
+#             return username  # pragma: nocover
+#
+#
+# def test_incorrect_multipart_installed_form_file(monkeypatch):
+#     monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)
+#     with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):
+#         app = Squall()
+#
+#         @app.post("/")
+#         async def root(username: str = Form(...), f: UploadFile = File(...)):
+#             return username  # pragma: nocover
+#
+#
+# def test_no_multipart_installed(monkeypatch):
+#     monkeypatch.delattr("multipart.__version__", raising=False)
+#     with pytest.raises(RuntimeError, match=multipart_not_installed_error):
+#         app = Squall()
+#
+#         @app.post("/")
+#         async def root(username: str = Form(...)):
+#             return username  # pragma: nocover
+#
+#
+# def test_no_multipart_installed_file(monkeypatch):
+#     monkeypatch.delattr("multipart.__version__", raising=False)
+#     with pytest.raises(RuntimeError, match=multipart_not_installed_error):
+#         app = Squall()
+#
+#         @app.post("/")
+#         async def root(f: UploadFile = File(...)):
+#             return f  # pragma: nocover
+#
+#
+# def test_no_multipart_installed_file_bytes(monkeypatch):
+#     monkeypatch.delattr("multipart.__version__", raising=False)
+#     with pytest.raises(RuntimeError, match=multipart_not_installed_error):
+#         app = Squall()
+#
+#         @app.post("/")
+#         async def root(f: bytes = File(...)):
+#             return f  # pragma: nocover
+#
+#
+# def test_no_multipart_installed_multi_form(monkeypatch):
+#     monkeypatch.delattr("multipart.__version__", raising=False)
+#     with pytest.raises(RuntimeError, match=multipart_not_installed_error):
+#         app = Squall()
+#
+#         @app.post("/")
+#         async def root(username: str = Form(...), password: str = Form(...)):
+#             return username  # pragma: nocover
+#
+#
+# def test_no_multipart_installed_form_file(monkeypatch):
+#     monkeypatch.delattr("multipart.__version__", raising=False)
+#     with pytest.raises(RuntimeError, match=multipart_not_installed_error):
+#         app = Squall()
+#
+#         @app.post("/")
+#         async def root(username: str = Form(...), f: UploadFile = File(...)):
+#             return username  # pragma: nocover
diff --git a/tests/test_param_class.py b/tests/test_param_class.py
deleted file mode 100644
index c76165a..0000000
--- a/tests/test_param_class.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from typing import Optional
-
-from squall import Squall
-from squall.params import Param
-from squall.testclient import TestClient
-
-app = Squall()
-
-
-@app.get("/items/")
-def read_items(q: Optional[str] = Param(None)):  # type: ignore
-    return {"q": q}
-
-
-client = TestClient(app)
-
-
-def test_default_param_query_none():
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"q": None}
-
-
-def test_default_param_query():
-    response = client.get("/items/?q=foo")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"q": "foo"}
diff --git a/tests/test_param_in_path_and_dependency.py b/tests/test_param_in_path_and_dependency.py
deleted file mode 100644
index 0022d88..0000000
--- a/tests/test_param_in_path_and_dependency.py
+++ /dev/null
@@ -1,93 +0,0 @@
-from squall import Depends, Squall
-from squall.testclient import TestClient
-
-app = Squall()
-
-
-async def user_exists(user_id: int):
-    return True
-
-
-@app.get("/users/{user_id}", dependencies=[Depends(user_exists)])
-async def read_users(user_id: int):
-    pass
-
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/users/{user_id}": {
-            "get": {
-                "summary": "Read Users",
-                "operationId": "read_users_users__user_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "User Id", "type": "integer"},
-                        "name": "user_id",
-                        "in": "path",
-                    },
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-        }
-    },
-}
-
-
-def test_reused_param():
-    response = client.get("/openapi.json")
-    data = response.json()
-    assert data == openapi_schema
-
-
-def test_read_users():
-    response = client.get("/users/42")
-    assert response.status_code == 200, response.text
diff --git a/tests/test_params_repr.py b/tests/test_params_repr.py
index 57a3548..0a2c311 100644
--- a/tests/test_params_repr.py
+++ b/tests/test_params_repr.py
@@ -1,48 +1,48 @@
-from typing import Any, List
-
-import pytest
-from squall.params import Body, Cookie, Depends, Header, Param, Path, Query
-
-test_data: List[Any] = ["teststr", None, ..., 1, []]
-
-
-def get_user():
-    return {}  # pragma: no cover
-
-
-@pytest.fixture(scope="function", params=test_data)
-def params(request):
-    return request.param
-
-
-def test_param_repr(params):
-    assert repr(Param(params)) == "Param(" + str(params) + ")"
-
-
-def test_path_repr(params):
-    assert repr(Path(params)) == "Path(Ellipsis)"
-
-
-def test_query_repr(params):
-    assert repr(Query(params)) == "Query(" + str(params) + ")"
-
-
-def test_header_repr(params):
-    assert repr(Header(params)) == "Header(" + str(params) + ")"
-
-
-def test_cookie_repr(params):
-    assert repr(Cookie(params)) == "Cookie(" + str(params) + ")"
-
-
-def test_body_repr(params):
-    assert repr(Body(params)) == "Body(" + str(params) + ")"
-
-
-def test_depends_repr():
-    assert repr(Depends()) == "Depends(NoneType)"
-    assert repr(Depends(get_user)) == "Depends(get_user)"
-    assert repr(Depends(use_cache=False)) == "Depends(NoneType, use_cache=False)"
-    assert (
-        repr(Depends(get_user, use_cache=False)) == "Depends(get_user, use_cache=False)"
-    )
+# from typing import Any, List
+#
+# import pytest
+# from squall.params import Body, Cookie, Depends, Header, Param, Path, Query
+#
+# test_data: List[Any] = ["teststr", None, ..., 1, []]
+#
+#
+# def get_user():
+#     return {}  # pragma: no cover
+#
+#
+# @pytest.fixture(scope="function", params=test_data)
+# def params(request):
+#     return request.param
+#
+#
+# def test_param_repr(params):
+#     assert repr(Param(params)) == "Param(" + str(params) + ")"
+#
+#
+# def test_path_repr(params):
+#     assert repr(Path(params)) == "Path(Ellipsis)"
+#
+#
+# def test_query_repr(params):
+#     assert repr(Query(params)) == "Query(" + str(params) + ")"
+#
+#
+# def test_header_repr(params):
+#     assert repr(Header(params)) == "Header(" + str(params) + ")"
+#
+#
+# def test_cookie_repr(params):
+#     assert repr(Cookie(params)) == "Cookie(" + str(params) + ")"
+#
+#
+# def test_body_repr(params):
+#     assert repr(Body(params)) == "Body(" + str(params) + ")"
+#
+#
+# def test_depends_repr():
+#     assert repr(Depends()) == "Depends(NoneType)"
+#     assert repr(Depends(get_user)) == "Depends(get_user)"
+#     assert repr(Depends(use_cache=False)) == "Depends(NoneType, use_cache=False)"
+#     assert (
+#         repr(Depends(get_user, use_cache=False)) == "Depends(get_user, use_cache=False)"
+#     )
diff --git a/tests/test_path.py b/tests/test_path.py
index acf08df..149dff3 100644
--- a/tests/test_path.py
+++ b/tests/test_path.py
@@ -1,7 +1,198 @@
+import http
+from typing import Optional
+
 import pytest
+from squall import Squall
+from squall.params import Num, Param, Path, Query, Str
 from squall.testclient import TestClient
 
-from .main import app
+app = Squall()
+
+
+@app.add_api("/api_route")
+def non_operation():
+    return {"message": "Hello World"}
+
+
+def non_decorated_route():
+    return {"message": "Hello World"}
+
+
+app.add_api_route("/non_decorated_route", non_decorated_route)
+
+
+@app.get("/text")
+def get_text():
+    return "Hello World"
+
+
+@app.get("/path/{item_id}")
+def get_id(item_id):
+    return item_id
+
+
+@app.get("/path/str/{item_id}")
+def get_str_id(item_id: str):
+    return item_id
+
+
+@app.get("/path/int/{item_id}")
+def get_int_id(item_id: int):
+    return item_id
+
+
+@app.get("/path/float/{item_id}")
+def get_float_id(item_id: float):
+    return item_id
+
+
+@app.get("/path/param/{item_id}")
+def get_path_param_id(item_id: Optional[str] = Path(None)):
+    return item_id
+
+
+@app.get("/path/param-required/{item_id}")
+def get_path_param_required_id(item_id: str = Path(...)):
+    return item_id
+
+
+@app.get("/path/param-minlength/{item_id}")
+def get_path_param_min_length(item_id: str = Path(..., valid=Str(min_length=3))):
+    return item_id
+
+
+@app.get("/path/param-maxlength/{item_id}")
+def get_path_param_max_length(item_id: str = Path(..., valid=Str(max_length=3))):
+    return item_id
+
+
+@app.get("/path/param-min_maxlength/{item_id}")
+def get_path_param_min_max_length(
+    item_id: str = Path(..., valid=Str(max_length=3, min_length=2))
+):
+    return item_id
+
+
+@app.get("/path/param-gt/{item_id}")
+def get_path_param_gt(item_id: float = Path(..., valid=Num(gt=3))):
+    return item_id
+
+
+@app.get("/path/param-gt0/{item_id}")
+def get_path_param_gt0(item_id: float = Path(..., valid=Num(gt=0))):
+    return item_id
+
+
+@app.get("/path/param-ge/{item_id}")
+def get_path_param_ge(item_id: float = Path(..., valid=Num(ge=3))):
+    return item_id
+
+
+@app.get("/path/param-lt/{item_id}")
+def get_path_param_lt(item_id: float = Path(..., valid=Num(lt=3))):
+    return item_id
+
+
+@app.get("/path/param-lt0/{item_id}")
+def get_path_param_lt0(item_id: float = Path(..., valid=Num(lt=0))):
+    return item_id
+
+
+@app.get("/path/param-le/{item_id}")
+def get_path_param_le(item_id: float = Path(..., valid=Num(le=3))):
+    return item_id
+
+
+@app.get("/path/param-lt-gt/{item_id}")
+def get_path_param_lt_gt(item_id: float = Path(..., valid=Num(lt=3, gt=1))):
+    return item_id
+
+
+@app.get("/path/param-le-ge/{item_id}")
+def get_path_param_le_ge(item_id: float = Path(..., valid=Num(le=3, ge=1))):
+    return item_id
+
+
+@app.get("/path/param-lt-int/{item_id}")
+def get_path_param_lt_int(item_id: int = Path(..., valid=Num(lt=3))):
+    return item_id
+
+
+@app.get("/path/param-gt-int/{item_id}")
+def get_path_param_gt_int(item_id: int = Path(..., valid=Num(gt=3))):
+    return item_id
+
+
+@app.get("/path/param-le-int/{item_id}")
+def get_path_param_le_int(item_id: int = Path(..., valid=Num(le=3))):
+    return item_id
+
+
+@app.get("/path/param-ge-int/{item_id}")
+def get_path_param_ge_int(item_id: int = Path(..., valid=Num(ge=3))):
+    return item_id
+
+
+@app.get("/path/param-lt-gt-int/{item_id}")
+def get_path_param_lt_gt_int(item_id: int = Path(..., valid=Num(lt=3, gt=1))):
+    return item_id
+
+
+@app.get("/path/param-le-ge-int/{item_id}")
+def get_path_param_le_ge_int(item_id: int = Param(..., valid=Num(le=3, ge=1))):
+    return item_id
+
+
+@app.get("/query")
+def get_query(query):
+    return f"foo bar {query}"
+
+
+@app.get("/query/optional")
+def get_query_optional(query=None):
+    if query is None:
+        return "foo bar"
+    return f"foo bar {query}"
+
+
+@app.get("/query/int")
+def get_query_type(query: int):
+    return f"foo bar {query}"
+
+
+@app.get("/query/int/optional")
+def get_query_type_optional(query: Optional[int] = None):
+    if query is None:
+        return "foo bar"
+    return f"foo bar {query}"
+
+
+@app.get("/query/int/default")
+def get_query_type_int_default(query: int = 10):
+    return f"foo bar {query}"
+
+
+@app.get("/query/param")
+def get_query_param(query=Query(None)):
+    if query is None:
+        return "foo bar"
+    return f"foo bar {query}"
+
+
+@app.get("/query/param-required")
+def get_query_param_required(query=Query(...)):
+    return f"foo bar {query}"
+
+
+@app.get("/query/param-required/int")
+def get_query_param_required_type(query: int = Query(...)):
+    return f"foo bar {query}"
+
+
+@app.get("/enum-status-code", status_code=http.HTTPStatus.CREATED)
+def get_enum_status_code():
+    return "foo bar"
+
 
 client = TestClient(app)
 
@@ -29,141 +220,87 @@ def test_nonexistent():
 }
 
 response_not_valid_int = {
-    "detail": [
-        {
-            "loc": ["path", "item_id"],
-            "msg": "value is not a valid integer",
-            "type": "type_error.integer",
-        }
+    "details": [
+        {"loc": ["path_params", "item_id"], "msg": "Cast of `int` failed", "val": "2.7"}
     ]
 }
 
 response_not_valid_float = {
-    "detail": [
+    "details": [
         {
-            "loc": ["path", "item_id"],
-            "msg": "value is not a valid float",
-            "type": "type_error.float",
+            "loc": ["path_params", "item_id"],
+            "msg": "Cast of `float` failed",
+            "val": "True",
         }
     ]
 }
 
 response_at_least_3 = {
-    "detail": [
-        {
-            "loc": ["path", "item_id"],
-            "msg": "ensure this value has at least 3 characters",
-            "type": "value_error.any_str.min_length",
-            "ctx": {"limit_value": 3},
-        }
+    "details": [
+        {"loc": ["path_params", "item_id"], "msg": "Validation error", "val": "fo"}
     ]
 }
 
 
 response_at_least_2 = {
-    "detail": [
-        {
-            "loc": ["path", "item_id"],
-            "msg": "ensure this value has at least 2 characters",
-            "type": "value_error.any_str.min_length",
-            "ctx": {"limit_value": 2},
-        }
+    "details": [
+        {"loc": ["path_params", "item_id"], "msg": "Validation error", "val": "f"}
     ]
 }
 
 
 response_maximum_3 = {
-    "detail": [
-        {
-            "loc": ["path", "item_id"],
-            "msg": "ensure this value has at most 3 characters",
-            "type": "value_error.any_str.max_length",
-            "ctx": {"limit_value": 3},
-        }
+    "details": [
+        {"loc": ["path_params", "item_id"], "msg": "Validation error", "val": "foobar"}
     ]
 }
 
 
 response_greater_than_3 = {
-    "detail": [
-        {
-            "loc": ["path", "item_id"],
-            "msg": "ensure this value is greater than 3",
-            "type": "value_error.number.not_gt",
-            "ctx": {"limit_value": 3},
-        }
+    "details": [
+        {"loc": ["path_params", "item_id"], "msg": "Validation error", "val": 2}
     ]
 }
 
 
 response_greater_than_0 = {
-    "detail": [
-        {
-            "loc": ["path", "item_id"],
-            "msg": "ensure this value is greater than 0",
-            "type": "value_error.number.not_gt",
-            "ctx": {"limit_value": 0},
-        }
+    "details": [
+        {"loc": ["path_params", "item_id"], "msg": "Validation error", "val": 0.0}
     ]
 }
 
 
 response_greater_than_1 = {
-    "detail": [
-        {
-            "loc": ["path", "item_id"],
-            "msg": "ensure this value is greater than 1",
-            "type": "value_error.number.not_gt",
-            "ctx": {"limit_value": 1},
-        }
+    "details": [
+        {"loc": ["path_params", "item_id"], "msg": "Validation error", "val": 0}
     ]
 }
 
 
 response_greater_than_equal_3 = {
-    "detail": [
-        {
-            "loc": ["path", "item_id"],
-            "msg": "ensure this value is greater than or equal to 3",
-            "type": "value_error.number.not_ge",
-            "ctx": {"limit_value": 3},
-        }
+    "details": [
+        {"loc": ["path_params", "item_id"], "msg": "Validation error", "val": 2}
     ]
 }
 
 
 response_less_than_3 = {
-    "detail": [
-        {
-            "loc": ["path", "item_id"],
-            "msg": "ensure this value is less than 3",
-            "type": "value_error.number.not_lt",
-            "ctx": {"limit_value": 3},
-        }
+    "details": [
+        {"loc": ["path_params", "item_id"], "msg": "Validation error", "val": 4}
     ]
 }
 
 
 response_less_than_0 = {
-    "detail": [
-        {
-            "loc": ["path", "item_id"],
-            "msg": "ensure this value is less than 0",
-            "type": "value_error.number.not_lt",
-            "ctx": {"limit_value": 0},
-        }
+    "details": [
+        {"loc": ["path_params", "item_id"], "msg": "Validation error", "val": 0}
     ]
 }
 
 
 response_less_than_equal_3 = {
-    "detail": [
-        {
-            "loc": ["path", "item_id"],
-            "msg": "ensure this value is less than or equal to 3",
-            "type": "value_error.number.not_le",
-            "ctx": {"limit_value": 3},
-        }
+    "details": [
+        {"loc": ["path_params", "item_id"], "msg": "Validation error", "val": 4}
     ]
 }
 
@@ -175,76 +312,65 @@ def test_nonexistent():
         ("/path/str/foobar", 200, "foobar"),
         ("/path/str/42", 200, "42"),
         ("/path/str/True", 200, "True"),
-        ("/path/int/foobar", 422, response_not_valid_int),
-        ("/path/int/True", 422, response_not_valid_int),
+        ("/path/int/2.7", 400, response_not_valid_int),
         ("/path/int/42", 200, 42),
-        ("/path/int/42.5", 422, response_not_valid_int),
-        ("/path/float/foobar", 422, response_not_valid_float),
-        ("/path/float/True", 422, response_not_valid_float),
+        ("/path/int/2.7", 400, response_not_valid_int),
+        ("/path/float/True", 400, response_not_valid_float),
         ("/path/float/42", 200, 42),
         ("/path/float/42.5", 200, 42.5),
-        ("/path/bool/foobar", 422, response_not_valid_bool),
-        ("/path/bool/True", 200, True),
-        ("/path/bool/42", 422, response_not_valid_bool),
-        ("/path/bool/42.5", 422, response_not_valid_bool),
-        ("/path/bool/1", 200, True),
-        ("/path/bool/0", 200, False),
-        ("/path/bool/true", 200, True),
-        ("/path/bool/False", 200, False),
-        ("/path/bool/false", 200, False),
         ("/path/param/foo", 200, "foo"),
         ("/path/param-required/foo", 200, "foo"),
         ("/path/param-minlength/foo", 200, "foo"),
-        ("/path/param-minlength/fo", 422, response_at_least_3),
+        ("/path/param-minlength/fo", 400, response_at_least_3),
         ("/path/param-maxlength/foo", 200, "foo"),
-        ("/path/param-maxlength/foobar", 422, response_maximum_3),
+        ("/path/param-maxlength/foobar", 400, response_maximum_3),
         ("/path/param-min_maxlength/foo", 200, "foo"),
-        ("/path/param-min_maxlength/foobar", 422, response_maximum_3),
-        ("/path/param-min_maxlength/f", 422, response_at_least_2),
-        ("/path/param-gt/42", 200, 42),
-        ("/path/param-gt/2", 422, response_greater_than_3),
+        ("/path/param-min_maxlength/foobar", 400, response_maximum_3),
+        ("/path/param-min_maxlength/f", 400, response_at_least_2),
+        ("/path/param-gt/4", 200, 4),
+        ("/path/param-gt/2", 400, response_greater_than_3),
         ("/path/param-gt0/0.05", 200, 0.05),
-        ("/path/param-gt0/0", 422, response_greater_than_0),
-        ("/path/param-ge/42", 200, 42),
+        ("/path/param-gt0/0", 400, response_greater_than_0),
+        ("/path/param-ge/4", 200, 4),
         ("/path/param-ge/3", 200, 3),
-        ("/path/param-ge/2", 422, response_greater_than_equal_3),
-        ("/path/param-lt/42", 422, response_less_than_3),
+        ("/path/param-ge/2", 400, response_greater_than_equal_3),
+        ("/path/param-lt/4", 400, response_less_than_3),
         ("/path/param-lt/2", 200, 2),
         ("/path/param-lt0/-1", 200, -1),
-        ("/path/param-lt0/0", 422, response_less_than_0),
-        ("/path/param-le/42", 422, response_less_than_equal_3),
+        ("/path/param-lt0/0", 400, response_less_than_0),
+        ("/path/param-le/4", 400, response_less_than_equal_3),
         ("/path/param-le/3", 200, 3),
         ("/path/param-le/2", 200, 2),
         ("/path/param-lt-gt/2", 200, 2),
-        ("/path/param-lt-gt/4", 422, response_less_than_3),
-        ("/path/param-lt-gt/0", 422, response_greater_than_1),
+        ("/path/param-lt-gt/4", 400, response_less_than_3),
+        ("/path/param-lt-gt/0", 400, response_greater_than_1),
         ("/path/param-le-ge/2", 200, 2),
         ("/path/param-le-ge/1", 200, 1),
         ("/path/param-le-ge/3", 200, 3),
-        ("/path/param-le-ge/4", 422, response_less_than_equal_3),
+        ("/path/param-le-ge/4", 400, response_less_than_equal_3),
         ("/path/param-lt-int/2", 200, 2),
-        ("/path/param-lt-int/42", 422, response_less_than_3),
-        ("/path/param-lt-int/2.7", 422, response_not_valid_int),
-        ("/path/param-gt-int/42", 200, 42),
-        ("/path/param-gt-int/2", 422, response_greater_than_3),
-        ("/path/param-gt-int/2.7", 422, response_not_valid_int),
-        ("/path/param-le-int/42", 422, response_less_than_equal_3),
+        ("/path/param-lt-int/4", 400, response_less_than_3),
+        ("/path/param-lt-int/2.7", 400, response_not_valid_int),
+        ("/path/param-gt-int/4", 200, 4),
+        ("/path/param-gt-int/2", 400, response_greater_than_3),
+        ("/path/param-gt-int/2.7", 400, response_not_valid_int),
+        ("/path/param-le-int/4", 400, response_less_than_equal_3),
         ("/path/param-le-int/3", 200, 3),
         ("/path/param-le-int/2", 200, 2),
-        ("/path/param-le-int/2.7", 422, response_not_valid_int),
+        ("/path/param-le-int/2.7", 400, response_not_valid_int),
         ("/path/param-ge-int/42", 200, 42),
         ("/path/param-ge-int/3", 200, 3),
-        ("/path/param-ge-int/2", 422, response_greater_than_equal_3),
-        ("/path/param-ge-int/2.7", 422, response_not_valid_int),
+        ("/path/param-ge-int/2", 400, response_greater_than_equal_3),
+        ("/path/param-ge-int/2.7", 400, response_not_valid_int),
         ("/path/param-lt-gt-int/2", 200, 2),
-        ("/path/param-lt-gt-int/4", 422, response_less_than_3),
-        ("/path/param-lt-gt-int/0", 422, response_greater_than_1),
-        ("/path/param-lt-gt-int/2.7", 422, response_not_valid_int),
+        ("/path/param-lt-gt-int/4", 400, response_less_than_3),
+        ("/path/param-lt-gt-int/0", 400, response_greater_than_1),
+        ("/path/param-lt-gt-int/2.7", 400, response_not_valid_int),
         ("/path/param-le-ge-int/2", 200, 2),
         ("/path/param-le-ge-int/1", 200, 1),
         ("/path/param-le-ge-int/3", 200, 3),
-        ("/path/param-le-ge-int/4", 422, response_less_than_equal_3),
-        ("/path/param-le-ge-int/2.7", 422, response_not_valid_int),
+        ("/path/param-le-ge-int/4", 400, response_less_than_equal_3),
+        ("/path/param-le-ge-int/2.7", 400, response_not_valid_int),
     ],
 )
 def test_get_path(path, expected_status, expected_response):
diff --git a/tests/test_query.py b/tests/test_query.py
index 742cbc1..290ebc7 100644
--- a/tests/test_query.py
+++ b/tests/test_query.py
@@ -1,27 +1,73 @@
+import http
+from typing import Optional
+
 import pytest
+from squall import Query, Squall
 from squall.testclient import TestClient
 
-from .main import app
+app = Squall()
+
+
+@app.get("/query")
+def get_query(query=Query(...)):
+    return f"foo bar {query}"
+
+
+@app.get("/query/optional")
+def get_query_optional(query=Query(None)):
+    if query is None:
+        return "foo bar"
+    return f"foo bar {query}"
+
+
+@app.get("/query/int")
+def get_query_type(query: int = Query(...)):
+    return f"foo bar {query}"
+
+
+@app.get("/query/int/optional")
+def get_query_type_optional(query: Optional[int] = Query(None)):
+    if query is None:
+        return "foo bar"
+    return f"foo bar {query}"
+
+
+@app.get("/query/int/default")
+def get_query_type_int_default(query: int = Query(10)):
+    return f"foo bar {query}"
+
+
+@app.get("/query/param")
+def get_query_param(query=Query(None)):
+    if query is None:
+        return "foo bar"
+    return f"foo bar {query}"
+
+
+@app.get("/query/param-required")
+def get_query_param_required(query=Query(...)):
+    return f"foo bar {query}"
+
+
+@app.get("/query/param-required/int")
+def get_query_param_required_type(query: int = Query(...)):
+    return f"foo bar {query}"
+
+
+@app.get("/enum-status-code", status_code=http.HTTPStatus.CREATED)
+def get_enum_status_code():
+    return "foo bar"
+
 
 client = TestClient(app)
 
 response_missing = {
-    "detail": [
-        {
-            "loc": ["query", "query"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        }
-    ]
+    "details": [{"loc": ["query_params", "query"], "msg": "Mandatory field missed"}]
 }
 
 response_not_valid_int = {
-    "detail": [
-        {
-            "loc": ["query", "query"],
-            "msg": "value is not a valid integer",
-            "type": "type_error.integer",
-        }
+    "details": [
+        {"loc": ["query_params", "query"], "msg": "Cast of `int` failed", "val": "foo"}
     ]
 }
 
@@ -29,30 +75,22 @@
 @pytest.mark.parametrize(
     "path,expected_status,expected_response",
     [
-        ("/query", 422, response_missing),
+        ("/query", 400, response_missing),
         ("/query?query=baz", 200, "foo bar baz"),
-        ("/query?not_declared=baz", 422, response_missing),
+        ("/query?not_declared=baz", 400, response_missing),
         ("/query/optional", 200, "foo bar"),
         ("/query/optional?query=baz", 200, "foo bar baz"),
         ("/query/optional?not_declared=baz", 200, "foo bar"),
-        ("/query/int", 422, response_missing),
+        ("/query/int", 400, response_missing),
         ("/query/int?query=42", 200, "foo bar 42"),
-        ("/query/int?query=42.5", 422, response_not_valid_int),
-        ("/query/int?query=baz", 422, response_not_valid_int),
-        ("/query/int?not_declared=baz", 422, response_missing),
+        ("/query/int?query=foo", 400, response_not_valid_int),
+        ("/query/int?not_declared=baz", 400, response_missing),
         ("/query/int/optional", 200, "foo bar"),
         ("/query/int/optional?query=50", 200, "foo bar 50"),
-        ("/query/int/optional?query=foo", 422, response_not_valid_int),
+        ("/query/int/optional?query=foo", 400, response_not_valid_int),
         ("/query/int/default", 200, "foo bar 10"),
         ("/query/int/default?query=50", 200, "foo bar 50"),
-        ("/query/int/default?query=foo", 422, response_not_valid_int),
-        ("/query/param", 200, "foo bar"),
-        ("/query/param?query=50", 200, "foo bar 50"),
-        ("/query/param-required", 422, response_missing),
-        ("/query/param-required?query=50", 200, "foo bar 50"),
-        ("/query/param-required/int", 422, response_missing),
-        ("/query/param-required/int?query=50", 200, "foo bar 50"),
-        ("/query/param-required/int?query=foo", 422, response_not_valid_int),
+        ("/query/int/default?query=foo", 400, response_not_valid_int),
     ],
 )
 def test_get_path(path, expected_status, expected_response):
diff --git a/tests/test_repeated_cookie_headers.py b/tests/test_repeated_cookie_headers.py
deleted file mode 100644
index bdd48d7..0000000
--- a/tests/test_repeated_cookie_headers.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from squall import Depends, Response, Squall
-from squall.testclient import TestClient
-
-app = Squall()
-
-
-def set_cookie(*, response: Response):
-    response.set_cookie("cookie-name", "cookie-value")
-    return {}
-
-
-def set_indirect_cookie(*, dep: str = Depends(set_cookie)):
-    return dep
-
-
-@app.get("/directCookie")
-def get_direct_cookie(dep: str = Depends(set_cookie)):
-    return {"dep": dep}
-
-
-@app.get("/indirectCookie")
-def get_indirect_cookie(dep: str = Depends(set_indirect_cookie)):
-    return {"dep": dep}
-
-
-client = TestClient(app)
-
-
-def test_cookie_is_set_once():
-    direct_response = client.get("/directCookie")
-    indirect_response = client.get("/indirectCookie")
-    assert (
-        direct_response.headers["set-cookie"] == indirect_response.headers["set-cookie"]
-    )
diff --git a/tests/test_repeated_dependency_schema.py b/tests/test_repeated_dependency_schema.py
deleted file mode 100644
index dfdaf0d..0000000
--- a/tests/test_repeated_dependency_schema.py
+++ /dev/null
@@ -1,102 +0,0 @@
-from squall import Depends, Header, Squall, status
-from squall.testclient import TestClient
-
-app = Squall()
-
-
-def get_header(*, someheader: str = Header(...)):
-    return someheader
-
-
-def get_something_else(*, someheader: str = Depends(get_header)):
-    return f"{someheader}123"
-
-
-@app.get("/")
-def get_deps(dep1: str = Depends(get_header), dep2: str = Depends(get_something_else)):
-    return {"dep1": dep1, "dep2": dep2}
-
-
-client = TestClient(app)
-
-schema = {
-    "components": {
-        "schemas": {
-            "HTTPValidationError": {
-                "properties": {
-                    "detail": {
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                        "title": "Detail",
-                        "type": "array",
-                    }
-                },
-                "title": "HTTPValidationError",
-                "type": "object",
-            },
-            "ValidationError": {
-                "properties": {
-                    "loc": {
-                        "items": {"type": "string"},
-                        "title": "Location",
-                        "type": "array",
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error " "Type", "type": "string"},
-                },
-                "required": ["loc", "msg", "type"],
-                "title": "ValidationError",
-                "type": "object",
-            },
-        }
-    },
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "openapi": "3.0.2",
-    "paths": {
-        "/": {
-            "get": {
-                "operationId": "get_deps__get",
-                "parameters": [
-                    {
-                        "in": "header",
-                        "name": "someheader",
-                        "required": True,
-                        "schema": {"title": "Someheader", "type": "string"},
-                    }
-                ],
-                "responses": {
-                    "200": {
-                        "content": {"application/json": {"schema": {}}},
-                        "description": "Successful " "Response",
-                    },
-                    "422": {
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                        "description": "Validation " "Error",
-                    },
-                },
-                "summary": "Get Deps",
-            }
-        }
-    },
-}
-
-
-def test_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == status.HTTP_200_OK
-    actual_schema = response.json()
-    assert actual_schema == schema
-    assert (
-        len(actual_schema["paths"]["/"]["get"]["parameters"]) == 1
-    )  # primary goal of this test
-
-
-def test_response():
-    response = client.get("/", headers={"someheader": "hello"})
-    assert response.status_code == status.HTTP_200_OK
-    assert response.json() == {"dep1": "hello", "dep2": "hello123"}
diff --git a/tests/test_request_body_parameters_media_type.py b/tests/test_request_body_parameters_media_type.py
index b4c39cc..64f2d7e 100644
--- a/tests/test_request_body_parameters_media_type.py
+++ b/tests/test_request_body_parameters_media_type.py
@@ -1,5 +1,6 @@
 import typing
 
+import pytest
 from pydantic import BaseModel
 from squall import Body, Squall
 from squall.testclient import TestClient
@@ -54,6 +55,7 @@ async def create_shop(
 client = TestClient(app)
 
 
+@pytest.mark.skip("Fix OpenAPI required")
 def test_openapi_schema():
     response = client.get("/openapi.json")
     assert response.status_code == 200, response.text
diff --git a/tests/test_response_change_status_code.py b/tests/test_response_change_status_code.py
index 0235de1..8ece528 100644
--- a/tests/test_response_change_status_code.py
+++ b/tests/test_response_change_status_code.py
@@ -1,26 +1,26 @@
-from squall import Depends, Response, Squall
-from squall.testclient import TestClient
-
-app = Squall()
-
-
-async def response_status_setter(response: Response):
-    response.status_code = 201
-
-
-async def parent_dep(result=Depends(response_status_setter)):
-    return result
-
-
-@app.get("/", dependencies=[Depends(parent_dep)])
-async def get_main():
-    return {"msg": "Hello World"}
-
-
-client = TestClient(app)
-
-
-def test_dependency_set_status_code():
-    response = client.get("/")
-    assert response.status_code == 201, response.text
-    assert response.json() == {"msg": "Hello World"}
+# from squall import Depends, Response, Squall
+# from squall.testclient import TestClient
+#
+# app = Squall()
+#
+#
+# async def response_status_setter(response: Response):
+#     response.status_code = 201
+#
+#
+# async def parent_dep(result=Depends(response_status_setter)):
+#     return result
+#
+#
+# @app.get("/", dependencies=[Depends(parent_dep)])
+# async def get_main():
+#     return {"msg": "Hello World"}
+#
+#
+# client = TestClient(app)
+#
+#
+# def test_dependency_set_status_code():
+#     response = client.get("/")
+#     assert response.status_code == 201, response.text
+#     assert response.json() == {"msg": "Hello World"}
diff --git a/tests/test_routing/test_base_router.py b/tests/test_routing/test_base_router.py
index e551f50..b89ee2b 100644
--- a/tests/test_routing/test_base_router.py
+++ b/tests/test_routing/test_base_router.py
@@ -12,11 +12,9 @@ def test_add_api_route_defaults(mocker):
         response_model=None,
         status_code=None,
         tags=[],
-        dependencies=[],
         summary=None,
         description=None,
         response_description="Successful Response",
-        dependency_overrides_provider=None,
         responses={},
         deprecated=None,
         methods=["GET"],
@@ -34,7 +32,7 @@ def test_add_api_route_custom(mocker):
     response_class = mocker.Mock()
     status_code = 200
     tags = ["happiness"]
-    dependencies = [mocker.Mock()]
+    [mocker.Mock()]
     summary = "summary"
     description = "description"
     response_description = "response_description"
@@ -51,7 +49,6 @@ def test_add_api_route_custom(mocker):
         response_model=response_model,
         status_code=status_code,
         tags=tags,
-        dependencies=dependencies,
         summary=summary,
         description=description,
         response_description=response_description,
@@ -69,8 +66,6 @@ def test_add_api_route_custom(mocker):
         response_model=response_model,
         status_code=status_code,
         tags=tags,
-        dependencies=dependencies,
-        dependency_overrides_provider=None,
         summary=summary,
         description=description,
         response_description=response_description,
diff --git a/tests/test_routing/test_compile_path.py b/tests/test_routing/test_compile_path.py
new file mode 100644
index 0000000..fd40910
--- /dev/null
+++ b/tests/test_routing/test_compile_path.py
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/tests/test_routing/test_utils.py b/tests/test_routing/test_utils.py
new file mode 100644
index 0000000..3455be5
--- /dev/null
+++ b/tests/test_routing/test_utils.py
@@ -0,0 +1,275 @@
+from typing import Optional
+
+from squall.params import Cookie, Header, Num, Param, Query, Str
+from squall.routing_.utils import get_handler_head_params
+
+
+def test_get_handler_args_no_args():
+    def handler():
+        pass
+
+    assert get_handler_head_params(handler) == []
+
+
+def test_get_handler_args_no_annotation():
+    def handler(a, b=Query(...), c=Param(...), d=Header(...), e=Cookie(...)):
+        pass
+
+    params = get_handler_head_params(handler)
+    assert params[0].convertor == "str"
+    assert params[0].default == Ellipsis
+    assert params[0].statements == {}
+    assert params[0].name == "a"
+    assert params[0].origin == "a"
+    assert params[0].source == "path_params"
+    assert params[0].validate is None
+
+    assert params[1].convertor == "str"
+    assert params[1].default == Ellipsis
+    assert params[1].statements == {}
+    assert params[1].name == "b"
+    assert params[1].origin == "b"
+    assert params[1].source == "query_params"
+    assert params[1].validate is None
+
+    assert params[2].convertor == "str"
+    assert params[2].default == Ellipsis
+    assert params[2].statements == {}
+    assert params[2].name == "c"
+    assert params[2].origin == "c"
+    assert params[2].source == "path_params"
+    assert params[2].validate is None
+
+    assert params[3].convertor == "str"
+    assert params[3].default == Ellipsis
+    assert params[3].statements == {}
+    assert params[3].name == "d"
+    assert params[3].origin == "d"
+    assert params[3].source == "headers"
+    assert params[3].validate is None
+
+    assert params[4].convertor == "str"
+    assert params[4].default == Ellipsis
+    assert params[4].statements == {}
+    assert params[4].name == "e"
+    assert params[4].origin == "e"
+    assert params[4].source == "cookies"
+    assert params[4].validate is None
+
+
+def test_get_handler_args_origin():
+    def handler(
+        b=Query(..., origin="from_b"),
+        c=Param(..., origin="from_c"),
+        d=Header(..., origin="from_d"),
+        e=Cookie(..., origin="from_e"),
+    ):
+        pass
+
+    params = get_handler_head_params(handler)
+    assert params[0].convertor == "str"
+    assert params[0].default == Ellipsis
+    assert params[0].statements == {}
+    assert params[0].name == "b"
+    assert params[0].origin == "from_b"
+    assert params[0].source == "query_params"
+    assert params[0].validate is None
+
+    assert params[1].convertor == "str"
+    assert params[1].default == Ellipsis
+    assert params[1].statements == {}
+    assert params[1].name == "c"
+    assert params[1].origin == "from_c"
+    assert params[1].source == "path_params"
+    assert params[1].validate is None
+
+    assert params[2].convertor == "str"
+    assert params[2].default == Ellipsis
+    assert params[2].statements == {}
+    assert params[2].name == "d"
+    assert params[2].origin == "from_d"
+    assert params[2].source == "headers"
+    assert params[2].validate is None
+
+    assert params[3].convertor == "str"
+    assert params[3].default == Ellipsis
+    assert params[3].statements == {}
+    assert params[3].name == "e"
+    assert params[3].origin == "from_e"
+    assert params[3].source == "cookies"
+    assert params[3].validate is None
+
+
+def test_get_handler_args_annotations():
+    def handler(b: int, c: str, d: bytes, e: float):
+        pass
+
+    params = get_handler_head_params(handler)
+    assert params[0].convertor == "int"
+    assert params[0].default == Ellipsis
+    assert params[0].statements == {}
+    assert params[0].name == "b"
+    assert params[0].source == "path_params"
+    assert params[0].validate is None
+
+    assert params[1].convertor == "str"
+    assert params[1].default == Ellipsis
+    assert params[1].statements == {}
+    assert params[1].name == "c"
+    assert params[1].source == "path_params"
+    assert params[1].validate is None
+
+    assert params[2].convertor == "bytes"
+    assert params[2].default == Ellipsis
+    assert params[2].statements == {}
+    assert params[2].name == "d"
+    assert params[2].source == "path_params"
+    assert params[2].validate is None
+
+    assert params[3].convertor == "float"
+    assert params[3].default == Ellipsis
+    assert params[3].statements == {}
+    assert params[3].name == "e"
+    assert params[3].source == "path_params"
+    assert params[3].validate is None
+
+
+def test_get_handler_args_direct_defaults():
+    def handler(
+        a: Optional[str] = None,
+        b: int = 1,
+        c: str = "Hey",
+        d: bytes = b"Hey",
+        e: float = 3.14,
+    ):
+        pass
+
+    params = get_handler_head_params(handler)
+    assert params[0].convertor == "str"
+    assert params[0].default is None
+    assert params[0].statements == {}
+    assert params[0].name == "a"
+    assert params[0].source == "path_params"
+    assert params[0].validate is None
+
+    assert params[1].convertor == "int"
+    assert params[1].default == 1
+    assert params[1].statements == {}
+    assert params[1].name == "b"
+    assert params[1].source == "path_params"
+    assert params[1].validate is None
+
+    assert params[2].convertor == "str"
+    assert params[2].default == "Hey"
+    assert params[2].statements == {}
+    assert params[2].name == "c"
+    assert params[2].source == "path_params"
+    assert params[2].validate is None
+
+    assert params[3].convertor == "bytes"
+    assert params[3].default == b"Hey"
+    assert params[3].statements == {}
+    assert params[3].name == "d"
+    assert params[3].source == "path_params"
+    assert params[3].validate is None
+
+    assert params[4].convertor == "float"
+    assert params[4].default == 3.14
+    assert params[4].statements == {}
+    assert params[4].name == "e"
+    assert params[4].source == "path_params"
+    assert params[4].validate is None
+
+
+def test_get_handler_args_assigned_instance_defaults():
+    def handler(
+        a: Optional[str] = Param(None),
+        b: int = Param(1),
+        c: str = Query("Hey"),
+        d: bytes = Header(b"Hey"),
+        e: float = Cookie(3.14),
+    ):
+        pass
+
+    params = get_handler_head_params(handler)
+    assert params[0].convertor == "str"
+    assert params[0].default is None
+    assert params[0].statements == {}
+    assert params[0].name == "a"
+    assert params[0].source == "path_params"
+    assert params[0].validate is None
+
+    assert params[1].convertor == "int"
+    assert params[1].default == 1
+    assert params[1].statements == {}
+    assert params[1].name == "b"
+    assert params[1].source == "path_params"
+    assert params[1].validate is None
+
+    assert params[2].convertor == "str"
+    assert params[2].default == "Hey"
+    assert params[2].statements == {}
+    assert params[2].name == "c"
+    assert params[2].source == "query_params"
+    assert params[2].validate is None
+
+    assert params[3].convertor == "bytes"
+    assert params[3].default == b"Hey"
+    assert params[3].statements == {}
+    assert params[3].name == "d"
+    assert params[3].source == "headers"
+    assert params[3].validate is None
+
+    assert params[4].convertor == "float"
+    assert params[4].default == 3.14
+    assert params[4].statements == {}
+    assert params[4].name == "e"
+    assert params[4].source == "cookies"
+    assert params[4].validate is None
+
+
+def test_get_handler_args_validation_parameters():
+    def handler(
+        a: Optional[str] = Param(None, valid=Str(min_length=2)),
+        b: int = Param(1, valid=Num(ge=1, le=2)),
+        c: str = Query("Hey", valid=Str(min_length=2, max_length=5)),
+        d: bytes = Header(b"Hey", valid=Str(min_length=2, max_length=5)),
+        e: float = Cookie(3.14, valid=Num(ge=3.14, le=3.15)),
+    ):
+        pass
+
+    params = get_handler_head_params(handler)
+    assert params[0].convertor == "str"
+    assert params[0].default is None
+    assert params[0].statements["min_length"] == 2
+    assert params[0].name == "a"
+    assert params[0].source == "path_params"
+    assert params[0].validate == "string"
+
+    assert params[1].convertor == "int"
+    assert params[1].default == 1
+    assert params[1].statements == {"ge": 1, "le": 2}
+    assert params[1].name == "b"
+    assert params[1].source == "path_params"
+    assert params[1].validate == "numeric"
+
+    assert params[2].convertor == "str"
+    assert params[2].default == "Hey"
+    assert params[2].statements == {"max_length": 5, "min_length": 2}
+    assert params[2].name == "c"
+    assert params[2].source == "query_params"
+    assert params[2].validate == "string"
+
+    assert params[3].convertor == "bytes"
+    assert params[3].default == b"Hey"
+    assert params[3].statements == {"max_length": 5, "min_length": 2}
+    assert params[3].name == "d"
+    assert params[3].source == "headers"
+    assert params[3].validate == "string"
+
+    assert params[4].convertor == "float"
+    assert params[4].default == 3.14
+    assert params[4].statements == {"ge": 3.14, "le": 3.15}
+    assert params[4].name == "e"
+    assert params[4].source == "cookies"
+    assert params[4].validate == "numeric"
diff --git a/tests/test_tutorial/test_additional_responses/__init__.py b/tests/test_tutorial/test_additional_responses/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_additional_responses/test_tutorial001.py b/tests/test_tutorial/test_additional_responses/test_tutorial001.py
deleted file mode 100644
index 35c52a6..0000000
--- a/tests/test_tutorial/test_additional_responses/test_tutorial001.py
+++ /dev/null
@@ -1,116 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.additional_responses.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "get": {
-                "responses": {
-                    "404": {
-                        "description": "Not Found",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Message"}
-                            }
-                        },
-                    },
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Item"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Item",
-                "operationId": "read_item_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "required": ["id", "value"],
-                "type": "object",
-                "properties": {
-                    "id": {"title": "Id", "type": "string"},
-                    "value": {"title": "Value", "type": "string"},
-                },
-            },
-            "Message": {
-                "title": "Message",
-                "required": ["message"],
-                "type": "object",
-                "properties": {"message": {"title": "Message", "type": "string"}},
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_path_operation():
-    response = client.get("/items/foo")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"id": "foo", "value": "there goes my hero"}
-
-
-def test_path_operation_not_found():
-    response = client.get("/items/bar")
-    assert response.status_code == 404, response.text
-    assert response.json() == {"message": "Item not found"}
diff --git a/tests/test_tutorial/test_additional_responses/test_tutorial002.py b/tests/test_tutorial/test_additional_responses/test_tutorial002.py
deleted file mode 100644
index 9aca4cb..0000000
--- a/tests/test_tutorial/test_additional_responses/test_tutorial002.py
+++ /dev/null
@@ -1,115 +0,0 @@
-import os
-import shutil
-
-from squall.testclient import TestClient
-
-from docs_src.additional_responses.tutorial002 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Return the JSON item or an image.",
-                        "content": {
-                            "image/png": {},
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Item"}
-                            },
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Item",
-                "operationId": "read_item_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Img", "type": "boolean"},
-                        "name": "img",
-                        "in": "query",
-                    },
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "required": ["id", "value"],
-                "type": "object",
-                "properties": {
-                    "id": {"title": "Id", "type": "string"},
-                    "value": {"title": "Value", "type": "string"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_path_operation():
-    response = client.get("/items/foo")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"id": "foo", "value": "there goes my hero"}
-
-
-def test_path_operation_img():
-    shutil.copy("./docs/en/docs/img/favicon.png", "./image.png")
-    response = client.get("/items/foo?img=1")
-    assert response.status_code == 200, response.text
-    assert response.headers["Content-Type"] == "image/png"
-    assert len(response.content)
-    os.remove("./image.png")
diff --git a/tests/test_tutorial/test_additional_responses/test_tutorial003.py b/tests/test_tutorial/test_additional_responses/test_tutorial003.py
deleted file mode 100644
index 626173e..0000000
--- a/tests/test_tutorial/test_additional_responses/test_tutorial003.py
+++ /dev/null
@@ -1,117 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.additional_responses.tutorial003 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "get": {
-                "responses": {
-                    "404": {
-                        "description": "The item was not found",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Message"}
-                            }
-                        },
-                    },
-                    "200": {
-                        "description": "Item requested by ID",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Item"},
-                                "example": {"id": "bar", "value": "The bar tenders"},
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Item",
-                "operationId": "read_item_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "required": ["id", "value"],
-                "type": "object",
-                "properties": {
-                    "id": {"title": "Id", "type": "string"},
-                    "value": {"title": "Value", "type": "string"},
-                },
-            },
-            "Message": {
-                "title": "Message",
-                "required": ["message"],
-                "type": "object",
-                "properties": {"message": {"title": "Message", "type": "string"}},
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_path_operation():
-    response = client.get("/items/foo")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"id": "foo", "value": "there goes my hero"}
-
-
-def test_path_operation_not_found():
-    response = client.get("/items/bar")
-    assert response.status_code == 404, response.text
-    assert response.json() == {"message": "Item not found"}
diff --git a/tests/test_tutorial/test_additional_responses/test_tutorial004.py b/tests/test_tutorial/test_additional_responses/test_tutorial004.py
deleted file mode 100644
index ec80ebd..0000000
--- a/tests/test_tutorial/test_additional_responses/test_tutorial004.py
+++ /dev/null
@@ -1,118 +0,0 @@
-import os
-import shutil
-
-from squall.testclient import TestClient
-
-from docs_src.additional_responses.tutorial004 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "get": {
-                "responses": {
-                    "404": {"description": "Item not found"},
-                    "302": {"description": "The item was moved"},
-                    "403": {"description": "Not enough privileges"},
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "image/png": {},
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Item"}
-                            },
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Item",
-                "operationId": "read_item_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Img", "type": "boolean"},
-                        "name": "img",
-                        "in": "query",
-                    },
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "required": ["id", "value"],
-                "type": "object",
-                "properties": {
-                    "id": {"title": "Id", "type": "string"},
-                    "value": {"title": "Value", "type": "string"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_path_operation():
-    response = client.get("/items/foo")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"id": "foo", "value": "there goes my hero"}
-
-
-def test_path_operation_img():
-    shutil.copy("./docs/en/docs/img/favicon.png", "./image.png")
-    response = client.get("/items/foo?img=1")
-    assert response.status_code == 200, response.text
-    assert response.headers["Content-Type"] == "image/png"
-    assert len(response.content)
-    os.remove("./image.png")
diff --git a/tests/test_tutorial/test_additional_status_codes/__init__.py b/tests/test_tutorial/test_additional_status_codes/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_additional_status_codes/test_tutorial001.py b/tests/test_tutorial/test_additional_status_codes/test_tutorial001.py
deleted file mode 100644
index f8e1d8f..0000000
--- a/tests/test_tutorial/test_additional_status_codes/test_tutorial001.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.additional_status_codes.tutorial001 import app
-
-client = TestClient(app)
-
-
-def test_update():
-    response = client.put("/items/foo", json={"name": "Wrestlers"})
-    assert response.status_code == 200, response.text
-    assert response.json() == {"name": "Wrestlers", "size": None}
-
-
-def test_create():
-    response = client.put("/items/red", json={"name": "Chillies"})
-    assert response.status_code == 201, response.text
-    assert response.json() == {"name": "Chillies", "size": None}
diff --git a/tests/test_tutorial/test_advanced_middleware/__init__.py b/tests/test_tutorial/test_advanced_middleware/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_advanced_middleware/test_tutorial001.py b/tests/test_tutorial/test_advanced_middleware/test_tutorial001.py
deleted file mode 100644
index a66f45f..0000000
--- a/tests/test_tutorial/test_advanced_middleware/test_tutorial001.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.advanced_middleware.tutorial001 import app
-
-
-def test_middleware():
-    client = TestClient(app, base_url="https://testserver")
-    response = client.get("/")
-    assert response.status_code == 200, response.text
-
-    client = TestClient(app)
-    response = client.get("/", allow_redirects=False)
-    assert response.status_code == 307, response.text
-    assert response.headers["location"] == "https://testserver/"
diff --git a/tests/test_tutorial/test_advanced_middleware/test_tutorial002.py b/tests/test_tutorial/test_advanced_middleware/test_tutorial002.py
deleted file mode 100644
index cc82f62..0000000
--- a/tests/test_tutorial/test_advanced_middleware/test_tutorial002.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.advanced_middleware.tutorial002 import app
-
-
-def test_middleware():
-    client = TestClient(app, base_url="http://example.com")
-    response = client.get("/")
-    assert response.status_code == 200, response.text
-    client = TestClient(app, base_url="http://subdomain.example.com")
-    response = client.get("/")
-    assert response.status_code == 200, response.text
-    client = TestClient(app, base_url="http://invalidhost")
-    response = client.get("/")
-    assert response.status_code == 400, response.text
diff --git a/tests/test_tutorial/test_advanced_middleware/test_tutorial003.py b/tests/test_tutorial/test_advanced_middleware/test_tutorial003.py
deleted file mode 100644
index 2737779..0000000
--- a/tests/test_tutorial/test_advanced_middleware/test_tutorial003.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from squall.responses import PlainTextResponse
-from squall.testclient import TestClient
-
-from docs_src.advanced_middleware.tutorial003 import app
-
-
-@app.get("/large")
-async def large():
-    return PlainTextResponse("x" * 4000, status_code=200)
-
-
-client = TestClient(app)
-
-
-def test_middleware():
-    response = client.get("/large", headers={"accept-encoding": "gzip"})
-    assert response.status_code == 200, response.text
-    assert response.text == "x" * 4000
-    assert response.headers["Content-Encoding"] == "gzip"
-    assert int(response.headers["Content-Length"]) < 4000
-    response = client.get("/")
-    assert response.status_code == 200, response.text
diff --git a/tests/test_tutorial/test_async_sql_databases/__init__.py b/tests/test_tutorial/test_async_sql_databases/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_async_sql_databases/test_tutorial001.py b/tests/test_tutorial/test_async_sql_databases/test_tutorial001.py
deleted file mode 100644
index 417f8fa..0000000
--- a/tests/test_tutorial/test_async_sql_databases/test_tutorial001.py
+++ /dev/null
@@ -1,131 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.async_sql_databases.tutorial001 import app
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/notes/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "title": "Response Read Notes Notes  Get",
-                                    "type": "array",
-                                    "items": {"$ref": "#/components/schemas/Note"},
-                                }
-                            }
-                        },
-                    }
-                },
-                "summary": "Read Notes",
-                "operationId": "read_notes_notes__get",
-            },
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Note"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create Note",
-                "operationId": "create_note_notes__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/NoteIn"}
-                        }
-                    },
-                    "required": True,
-                },
-            },
-        }
-    },
-    "components": {
-        "schemas": {
-            "NoteIn": {
-                "title": "NoteIn",
-                "required": ["text", "completed"],
-                "type": "object",
-                "properties": {
-                    "text": {"title": "Text", "type": "string"},
-                    "completed": {"title": "Completed", "type": "boolean"},
-                },
-            },
-            "Note": {
-                "title": "Note",
-                "required": ["id", "text", "completed"],
-                "type": "object",
-                "properties": {
-                    "id": {"title": "Id", "type": "integer"},
-                    "text": {"title": "Text", "type": "string"},
-                    "completed": {"title": "Completed", "type": "boolean"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    with TestClient(app) as client:
-        response = client.get("/openapi.json")
-        assert response.status_code == 200, response.text
-        assert response.json() == openapi_schema
-
-
-def test_create_read():
-    with TestClient(app) as client:
-        note = {"text": "Foo bar", "completed": False}
-        response = client.post("/notes/", json=note)
-        assert response.status_code == 200, response.text
-        data = response.json()
-        assert data["text"] == note["text"]
-        assert data["completed"] == note["completed"]
-        assert "id" in data
-        response = client.get("/notes/")
-        assert response.status_code == 200, response.text
-        assert data in response.json()
diff --git a/tests/test_tutorial/test_async_tests/__init__.py b/tests/test_tutorial/test_async_tests/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_async_tests/test_main.py b/tests/test_tutorial/test_async_tests/test_main.py
deleted file mode 100644
index 1f5d718..0000000
--- a/tests/test_tutorial/test_async_tests/test_main.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import pytest
-
-from docs_src.async_tests.test_main import test_root
-
-
-@pytest.mark.anyio
-async def test_async_testing():
-    await test_root()
diff --git a/tests/test_tutorial/test_background_tasks/__init__.py b/tests/test_tutorial/test_background_tasks/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_background_tasks/test_tutorial001.py b/tests/test_tutorial/test_background_tasks/test_tutorial001.py
deleted file mode 100644
index b98474c..0000000
--- a/tests/test_tutorial/test_background_tasks/test_tutorial001.py
+++ /dev/null
@@ -1,19 +0,0 @@
-import os
-from pathlib import Path
-
-from squall.testclient import TestClient
-
-from docs_src.background_tasks.tutorial001 import app
-
-client = TestClient(app)
-
-
-def test():
-    log = Path("log.txt")
-    if log.is_file():
-        os.remove(log)  # pragma: no cover
-    response = client.post("/send-notification/foo@example.com")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"message": "Notification sent in the background"}
-    with open("./log.txt") as f:
-        assert "notification for foo@example.com: some notification" in f.read()
diff --git a/tests/test_tutorial/test_background_tasks/test_tutorial002.py b/tests/test_tutorial/test_background_tasks/test_tutorial002.py
deleted file mode 100644
index c748119..0000000
--- a/tests/test_tutorial/test_background_tasks/test_tutorial002.py
+++ /dev/null
@@ -1,19 +0,0 @@
-import os
-from pathlib import Path
-
-from squall.testclient import TestClient
-
-from docs_src.background_tasks.tutorial002 import app
-
-client = TestClient(app)
-
-
-def test():
-    log = Path("log.txt")
-    if log.is_file():
-        os.remove(log)  # pragma: no cover
-    response = client.post("/send-notification/foo@example.com?q=some-query")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"message": "Message sent"}
-    with open("./log.txt") as f:
-        assert "found query: some-query\nmessage to foo@example.com" in f.read()
diff --git a/tests/test_tutorial/test_behind_a_proxy/__init__.py b/tests/test_tutorial/test_behind_a_proxy/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_behind_a_proxy/test_tutorial001.py b/tests/test_tutorial/test_behind_a_proxy/test_tutorial001.py
deleted file mode 100644
index fea36a7..0000000
--- a/tests/test_tutorial/test_behind_a_proxy/test_tutorial001.py
+++ /dev/null
@@ -1,37 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.behind_a_proxy.tutorial001 import app
-
-client = TestClient(app, root_path="/api/v1")
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/app": {
-            "get": {
-                "summary": "Read Main",
-                "operationId": "read_main_app_get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-            }
-        }
-    },
-    "servers": [{"url": "/api/v1"}],
-}
-
-
-def test_openapi():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200
-    assert response.json() == openapi_schema
-
-
-def test_main():
-    response = client.get("/app")
-    assert response.status_code == 200
-    assert response.json() == {"message": "Hello World", "root_path": "/api/v1"}
diff --git a/tests/test_tutorial/test_behind_a_proxy/test_tutorial002.py b/tests/test_tutorial/test_behind_a_proxy/test_tutorial002.py
deleted file mode 100644
index ae6d169..0000000
--- a/tests/test_tutorial/test_behind_a_proxy/test_tutorial002.py
+++ /dev/null
@@ -1,37 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.behind_a_proxy.tutorial002 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/app": {
-            "get": {
-                "summary": "Read Main",
-                "operationId": "read_main_app_get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-            }
-        }
-    },
-    "servers": [{"url": "/api/v1"}],
-}
-
-
-def test_openapi():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200
-    assert response.json() == openapi_schema
-
-
-def test_main():
-    response = client.get("/app")
-    assert response.status_code == 200
-    assert response.json() == {"message": "Hello World", "root_path": "/api/v1"}
diff --git a/tests/test_tutorial/test_behind_a_proxy/test_tutorial003.py b/tests/test_tutorial/test_behind_a_proxy/test_tutorial003.py
deleted file mode 100644
index 12857c9..0000000
--- a/tests/test_tutorial/test_behind_a_proxy/test_tutorial003.py
+++ /dev/null
@@ -1,41 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.behind_a_proxy.tutorial003 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "servers": [
-        {"url": "/api/v1"},
-        {"url": "https://stag.example.com", "description": "Staging environment"},
-        {"url": "https://prod.example.com", "description": "Production environment"},
-    ],
-    "paths": {
-        "/app": {
-            "get": {
-                "summary": "Read Main",
-                "operationId": "read_main_app_get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-            }
-        }
-    },
-}
-
-
-def test_openapi():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200
-    assert response.json() == openapi_schema
-
-
-def test_main():
-    response = client.get("/app")
-    assert response.status_code == 200
-    assert response.json() == {"message": "Hello World", "root_path": "/api/v1"}
diff --git a/tests/test_tutorial/test_behind_a_proxy/test_tutorial004.py b/tests/test_tutorial/test_behind_a_proxy/test_tutorial004.py
deleted file mode 100644
index 23599b7..0000000
--- a/tests/test_tutorial/test_behind_a_proxy/test_tutorial004.py
+++ /dev/null
@@ -1,40 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.behind_a_proxy.tutorial004 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "servers": [
-        {"url": "https://stag.example.com", "description": "Staging environment"},
-        {"url": "https://prod.example.com", "description": "Production environment"},
-    ],
-    "paths": {
-        "/app": {
-            "get": {
-                "summary": "Read Main",
-                "operationId": "read_main_app_get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-            }
-        }
-    },
-}
-
-
-def test_openapi():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200
-    assert response.json() == openapi_schema
-
-
-def test_main():
-    response = client.get("/app")
-    assert response.status_code == 200
-    assert response.json() == {"message": "Hello World", "root_path": "/api/v1"}
diff --git a/tests/test_tutorial/test_bigger_applications/__init__.py b/tests/test_tutorial/test_bigger_applications/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_bigger_applications/test_main.py b/tests/test_tutorial/test_bigger_applications/test_main.py
deleted file mode 100644
index 66f009f..0000000
--- a/tests/test_tutorial/test_bigger_applications/test_main.py
+++ /dev/null
@@ -1,498 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.bigger_applications.app.main import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/users/": {
-            "get": {
-                "tags": ["users"],
-                "summary": "Read Users",
-                "operationId": "read_users_users__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Token", "type": "string"},
-                        "name": "token",
-                        "in": "query",
-                    }
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-        "/users/me": {
-            "get": {
-                "tags": ["users"],
-                "summary": "Read User Me",
-                "operationId": "read_user_me_users_me_get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Token", "type": "string"},
-                        "name": "token",
-                        "in": "query",
-                    }
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-        "/users/{username}": {
-            "get": {
-                "tags": ["users"],
-                "summary": "Read User",
-                "operationId": "read_user_users__username__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Username", "type": "string"},
-                        "name": "username",
-                        "in": "path",
-                    },
-                    {
-                        "required": True,
-                        "schema": {"title": "Token", "type": "string"},
-                        "name": "token",
-                        "in": "query",
-                    },
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-        "/items/": {
-            "get": {
-                "tags": ["items"],
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Token", "type": "string"},
-                        "name": "token",
-                        "in": "query",
-                    },
-                    {
-                        "required": True,
-                        "schema": {"title": "X-Token", "type": "string"},
-                        "name": "x-token",
-                        "in": "header",
-                    },
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "404": {"description": "Not found"},
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-        "/items/{item_id}": {
-            "get": {
-                "tags": ["items"],
-                "summary": "Read Item",
-                "operationId": "read_item_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    },
-                    {
-                        "required": True,
-                        "schema": {"title": "Token", "type": "string"},
-                        "name": "token",
-                        "in": "query",
-                    },
-                    {
-                        "required": True,
-                        "schema": {"title": "X-Token", "type": "string"},
-                        "name": "x-token",
-                        "in": "header",
-                    },
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "404": {"description": "Not found"},
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            },
-            "put": {
-                "tags": ["items", "custom"],
-                "summary": "Update Item",
-                "operationId": "update_item_items__item_id__put",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    },
-                    {
-                        "required": True,
-                        "schema": {"title": "Token", "type": "string"},
-                        "name": "token",
-                        "in": "query",
-                    },
-                    {
-                        "required": True,
-                        "schema": {"title": "X-Token", "type": "string"},
-                        "name": "x-token",
-                        "in": "header",
-                    },
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "404": {"description": "Not found"},
-                    "403": {"description": "Operation forbidden"},
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            },
-        },
-        "/admin/": {
-            "post": {
-                "tags": ["admin"],
-                "summary": "Update Admin",
-                "operationId": "update_admin_admin__post",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Token", "type": "string"},
-                        "name": "token",
-                        "in": "query",
-                    },
-                    {
-                        "required": True,
-                        "schema": {"title": "X-Token", "type": "string"},
-                        "name": "x-token",
-                        "in": "header",
-                    },
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "418": {"description": "I'm a teapot"},
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-        "/": {
-            "get": {
-                "summary": "Root",
-                "operationId": "root__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Token", "type": "string"},
-                        "name": "token",
-                        "in": "query",
-                    }
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-    },
-    "components": {
-        "schemas": {
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-        }
-    },
-}
-
-
-no_jessica = {
-    "detail": [
-        {
-            "loc": ["query", "token"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        },
-    ]
-}
-
-
-@pytest.mark.parametrize(
-    "path,expected_status,expected_response,headers",
-    [
-        (
-            "/users?token=jessica",
-            200,
-            [{"username": "Rick"}, {"username": "Morty"}],
-            {},
-        ),
-        ("/users", 422, no_jessica, {}),
-        ("/users/foo?token=jessica", 200, {"username": "foo"}, {}),
-        ("/users/foo", 422, no_jessica, {}),
-        ("/users/me?token=jessica", 200, {"username": "fakecurrentuser"}, {}),
-        ("/users/me", 422, no_jessica, {}),
-        (
-            "/users?token=monica",
-            400,
-            {"detail": "No Jessica token provided"},
-            {},
-        ),
-        (
-            "/items?token=jessica",
-            200,
-            {"plumbus": {"name": "Plumbus"}, "gun": {"name": "Portal Gun"}},
-            {"X-Token": "fake-super-secret-token"},
-        ),
-        ("/items", 422, no_jessica, {"X-Token": "fake-super-secret-token"}),
-        (
-            "/items/plumbus?token=jessica",
-            200,
-            {"name": "Plumbus", "item_id": "plumbus"},
-            {"X-Token": "fake-super-secret-token"},
-        ),
-        (
-            "/items/bar?token=jessica",
-            404,
-            {"detail": "Item not found"},
-            {"X-Token": "fake-super-secret-token"},
-        ),
-        ("/items/plumbus", 422, no_jessica, {"X-Token": "fake-super-secret-token"}),
-        (
-            "/items?token=jessica",
-            400,
-            {"detail": "X-Token header invalid"},
-            {"X-Token": "invalid"},
-        ),
-        (
-            "/items/bar?token=jessica",
-            400,
-            {"detail": "X-Token header invalid"},
-            {"X-Token": "invalid"},
-        ),
-        (
-            "/items?token=jessica",
-            422,
-            {
-                "detail": [
-                    {
-                        "loc": ["header", "x-token"],
-                        "msg": "field required",
-                        "type": "value_error.missing",
-                    }
-                ]
-            },
-            {},
-        ),
-        (
-            "/items/plumbus?token=jessica",
-            422,
-            {
-                "detail": [
-                    {
-                        "loc": ["header", "x-token"],
-                        "msg": "field required",
-                        "type": "value_error.missing",
-                    }
-                ]
-            },
-            {},
-        ),
-        ("/?token=jessica", 200, {"message": "Hello Bigger Applications!"}, {}),
-        ("/", 422, no_jessica, {}),
-        ("/openapi.json", 200, openapi_schema, {}),
-    ],
-)
-@pytest.mark.skip(reason="SQUALL-20")
-def test_get_path(path, expected_status, expected_response, headers):
-    response = client.get(path, headers=headers)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
-
-
-@pytest.mark.skip(reason="SQUALL-20")
-def test_put_no_header():
-    response = client.put("/items/foo")
-    assert response.status_code == 422, response.text
-    assert response.json() == {
-        "detail": [
-            {
-                "loc": ["header", "x-token"],
-                "msg": "field required",
-                "type": "value_error.missing",
-            },
-            {
-                "loc": ["query", "token"],
-                "msg": "field required",
-                "type": "value_error.missing",
-            },
-        ]
-    }
-
-
-@pytest.mark.skip(reason="SQUALL-20")
-def test_put_invalid_header():
-    response = client.put("/items/foo", headers={"X-Token": "invalid"})
-    assert response.status_code == 400, response.text
-    assert response.json() == {"detail": "X-Token header invalid"}
-
-
-@pytest.mark.skip(reason="SQUALL-20")
-def test_put():
-    response = client.put(
-        "/items/plumbus?token=jessica", headers={"X-Token": "fake-super-secret-token"}
-    )
-    assert response.status_code == 200, response.text
-    assert response.json() == {"item_id": "plumbus", "name": "The great Plumbus"}
-
-
-@pytest.mark.skip(reason="SQUALL-20")
-def test_put_forbidden():
-    response = client.put(
-        "/items/bar?token=jessica", headers={"X-Token": "fake-super-secret-token"}
-    )
-    assert response.status_code == 403, response.text
-    assert response.json() == {"detail": "You can only update the item: plumbus"}
-
-
-@pytest.mark.skip(reason="SQUALL-20")
-def test_admin():
-    response = client.post(
-        "/admin/?token=jessica", headers={"X-Token": "fake-super-secret-token"}
-    )
-    assert response.status_code == 200, response.text
-    assert response.json() == {"message": "Admin getting schwifty"}
-
-
-@pytest.mark.skip(reason="SQUALL-20")
-def test_admin_invalid_header():
-    response = client.post("/admin/", headers={"X-Token": "invalid"})
-    assert response.status_code == 400, response.text
-    assert response.json() == {"detail": "X-Token header invalid"}
diff --git a/tests/test_tutorial/test_body/__init__.py b/tests/test_tutorial/test_body/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_body/test_tutorial001.py b/tests/test_tutorial/test_body/test_tutorial001.py
deleted file mode 100644
index 23b91dc..0000000
--- a/tests/test_tutorial/test_body/test_tutorial001.py
+++ /dev/null
@@ -1,279 +0,0 @@
-from unittest.mock import patch
-
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.body.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create Item",
-                "operationId": "create_item_items__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/Item"}
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "required": ["name", "price"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "price": {"title": "Price", "type": "number"},
-                    "description": {"title": "Description", "type": "string"},
-                    "tax": {"title": "Tax", "type": "number"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-price_missing = {
-    "detail": [
-        {
-            "loc": ["body", "price"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        }
-    ]
-}
-
-price_not_float = {
-    "detail": [
-        {
-            "loc": ["body", "price"],
-            "msg": "value is not a valid float",
-            "type": "type_error.float",
-        }
-    ]
-}
-
-name_price_missing = {
-    "detail": [
-        {
-            "loc": ["body", "name"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        },
-        {
-            "loc": ["body", "price"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        },
-    ]
-}
-
-body_missing = {
-    "detail": [
-        {"loc": ["body"], "msg": "field required", "type": "value_error.missing"}
-    ]
-}
-
-
-@pytest.mark.parametrize(
-    "path,body,expected_status,expected_response",
-    [
-        (
-            "/items/",
-            {"name": "Foo", "price": 50.5},
-            200,
-            {"name": "Foo", "price": 50.5, "description": None, "tax": None},
-        ),
-        (
-            "/items/",
-            {"name": "Foo", "price": "50.5"},
-            200,
-            {"name": "Foo", "price": 50.5, "description": None, "tax": None},
-        ),
-        (
-            "/items/",
-            {"name": "Foo", "price": "50.5", "description": "Some Foo"},
-            200,
-            {"name": "Foo", "price": 50.5, "description": "Some Foo", "tax": None},
-        ),
-        (
-            "/items/",
-            {"name": "Foo", "price": "50.5", "description": "Some Foo", "tax": 0.3},
-            200,
-            {"name": "Foo", "price": 50.5, "description": "Some Foo", "tax": 0.3},
-        ),
-        ("/items/", {"name": "Foo"}, 422, price_missing),
-        ("/items/", {"name": "Foo", "price": "twenty"}, 422, price_not_float),
-        ("/items/", {}, 422, name_price_missing),
-        ("/items/", None, 422, body_missing),
-    ],
-)
-def test_post_body(path, body, expected_status, expected_response):
-    response = client.post(path, json=body)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
-
-
-def test_post_broken_body():
-    response = client.post(
-        "/items/",
-        headers={"content-type": "application/json"},
-        data="{some broken json}",
-    )
-    assert response.status_code == 422, response.text
-    assert response.json() == {
-        "detail": [
-            {
-                "loc": ["body", 1],
-                "msg": "Expecting property name enclosed in double quotes: line 1 column 2 (char 1)",
-                "type": "value_error.jsondecode",
-                "ctx": {
-                    "msg": "Expecting property name enclosed in double quotes",
-                    "doc": "{some broken json}",
-                    "pos": 1,
-                    "lineno": 1,
-                    "colno": 2,
-                },
-            }
-        ]
-    }
-
-
-def test_post_form_for_json():
-    response = client.post("/items/", data={"name": "Foo", "price": 50.5})
-    assert response.status_code == 422, response.text
-    assert response.json() == {
-        "detail": [
-            {
-                "ctx": {"class_name": "Item"},
-                "loc": ["body"],
-                "msg": "instance of Item, tuple or dict expected",
-                "type": "type_error.dataclass",
-            }
-        ]
-    }
-
-
-def test_explicit_content_type():
-    response = client.post(
-        "/items/",
-        data='{"name": "Foo", "price": 50.5}',
-        headers={"Content-Type": "application/json"},
-    )
-    assert response.status_code == 200, response.text
-
-
-def test_geo_json():
-    response = client.post(
-        "/items/",
-        data='{"name": "Foo", "price": 50.5}',
-        headers={"Content-Type": "application/geo+json"},
-    )
-    assert response.status_code == 200, response.text
-
-
-def test_no_content_type_is_json():
-    response = client.post(
-        "/items/",
-        data='{"name": "Foo", "price": 50.5}',
-    )
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "name": "Foo",
-        "description": None,
-        "price": 50.5,
-        "tax": None,
-    }
-
-
-def test_wrong_headers():
-    data = '{"name": "Foo", "price": 50.5}'
-    invalid_dict = {
-        "detail": [
-            {
-                "loc": ["body"],
-                "ctx": {"class_name": "Item"},
-                "msg": "instance of Item, tuple or dict expected",
-                "type": "type_error.dataclass",
-            }
-        ]
-    }
-
-    response = client.post("/items/", data=data, headers={"Content-Type": "text/plain"})
-    assert response.status_code == 422, response.text
-    assert response.json() == invalid_dict
-
-    response = client.post(
-        "/items/", data=data, headers={"Content-Type": "application/geo+json-seq"}
-    )
-    assert response.status_code == 422, response.text
-    assert response.json() == invalid_dict
-    response = client.post(
-        "/items/", data=data, headers={"Content-Type": "application/not-really-json"}
-    )
-    assert response.status_code == 422, response.text
-    assert response.json() == invalid_dict
-
-
-def test_other_exceptions():
-    with patch("json.loads", side_effect=Exception):
-        response = client.post("/items/", json={"test": "test2"})
-        assert response.status_code == 400, response.text
diff --git a/tests/test_tutorial/test_body_fields/__init__.py b/tests/test_tutorial/test_body_fields/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_body_fields/test_tutorial001.py b/tests/test_tutorial/test_body_fields/test_tutorial001.py
deleted file mode 100644
index f0e13ad..0000000
--- a/tests/test_tutorial/test_body_fields/test_tutorial001.py
+++ /dev/null
@@ -1,169 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.body_fields.tutorial001 import app
-
-client = TestClient(app)
-
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "put": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Update Item",
-                "operationId": "update_item_items__item_id__put",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "integer"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {
-                                "$ref": "#/components/schemas/Body_update_item_items__item_id__put"
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "required": ["name", "price"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "description": {
-                        "title": "The description of the item",
-                        "maxLength": 300,
-                        "type": "string",
-                    },
-                    "price": {
-                        "title": "Price",
-                        "exclusiveMinimum": 0.0,
-                        "type": "number",
-                        "description": "The price must be greater than zero",
-                    },
-                    "tax": {"title": "Tax", "type": "number"},
-                },
-            },
-            "Body_update_item_items__item_id__put": {
-                "title": "Body_update_item_items__item_id__put",
-                "required": ["item"],
-                "type": "object",
-                "properties": {"item": {"$ref": "#/components/schemas/Item"}},
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-price_not_greater = {
-    "detail": [
-        {
-            "ctx": {"limit_value": 0},
-            "loc": ["body", "item", "price"],
-            "msg": "ensure this value is greater than 0",
-            "type": "value_error.number.not_gt",
-        }
-    ]
-}
-
-
-@pytest.mark.parametrize(
-    "path,body,expected_status,expected_response",
-    [
-        (
-            "/items/5",
-            {"item": {"name": "Foo", "price": 3.0}},
-            200,
-            {
-                "item_id": 5,
-                "item": {"name": "Foo", "price": 3.0, "description": None, "tax": None},
-            },
-        ),
-        (
-            "/items/6",
-            {
-                "item": {
-                    "name": "Bar",
-                    "price": 0.2,
-                    "description": "Some bar",
-                    "tax": "5.4",
-                }
-            },
-            200,
-            {
-                "item_id": 6,
-                "item": {
-                    "name": "Bar",
-                    "price": 0.2,
-                    "description": "Some bar",
-                    "tax": 5.4,
-                },
-            },
-        ),
-        ("/items/5", {"item": {"name": "Foo", "price": -3.0}}, 422, price_not_greater),
-    ],
-)
-def test(path, body, expected_status, expected_response):
-    response = client.put(path, json=body)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_body_multiple_params/__init__.py b/tests/test_tutorial/test_body_multiple_params/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_body_multiple_params/test_tutorial001.py b/tests/test_tutorial/test_body_multiple_params/test_tutorial001.py
deleted file mode 100644
index 9f894e9..0000000
--- a/tests/test_tutorial/test_body_multiple_params/test_tutorial001.py
+++ /dev/null
@@ -1,147 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.body_multiple_params.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "put": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Update Item",
-                "operationId": "update_item_items__item_id__put",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {
-                            "title": "The ID of the item to get",
-                            "maximum": 1000.0,
-                            "minimum": 0.0,
-                            "type": "integer",
-                        },
-                        "name": "item_id",
-                        "in": "path",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Q", "type": "string"},
-                        "name": "q",
-                        "in": "query",
-                    },
-                ],
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/Item"}
-                        }
-                    }
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "required": ["name", "price"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "price": {"title": "Price", "type": "number"},
-                    "description": {"title": "Description", "type": "string"},
-                    "tax": {"title": "Tax", "type": "number"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-item_id_not_int = {
-    "detail": [
-        {
-            "loc": ["path", "item_id"],
-            "msg": "value is not a valid integer",
-            "type": "type_error.integer",
-        }
-    ]
-}
-
-
-@pytest.mark.parametrize(
-    "path,body,expected_status,expected_response",
-    [
-        (
-            "/items/5?q=bar",
-            {"name": "Foo", "price": 50.5},
-            200,
-            {
-                "item_id": 5,
-                "item": {
-                    "name": "Foo",
-                    "price": 50.5,
-                    "description": None,
-                    "tax": None,
-                },
-                "q": "bar",
-            },
-        ),
-        ("/items/5?q=bar", None, 200, {"item_id": 5, "q": "bar"}),
-        ("/items/5", None, 200, {"item_id": 5}),
-        ("/items/foo", None, 422, item_id_not_int),
-    ],
-)
-def test_post_body(path, body, expected_status, expected_response):
-    response = client.put(path, json=body)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_body_multiple_params/test_tutorial003.py b/tests/test_tutorial/test_body_multiple_params/test_tutorial003.py
deleted file mode 100644
index 0f9df7c..0000000
--- a/tests/test_tutorial/test_body_multiple_params/test_tutorial003.py
+++ /dev/null
@@ -1,198 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.body_multiple_params.tutorial003 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "put": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Update Item",
-                "operationId": "update_item_items__item_id__put",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "integer"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {
-                                "$ref": "#/components/schemas/Body_update_item_items__item_id__put"
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "required": ["name", "price"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "price": {"title": "Price", "type": "number"},
-                    "description": {"title": "Description", "type": "string"},
-                    "tax": {"title": "Tax", "type": "number"},
-                },
-            },
-            "User": {
-                "title": "User",
-                "required": ["username"],
-                "type": "object",
-                "properties": {
-                    "username": {"title": "Username", "type": "string"},
-                    "full_name": {"title": "Full Name", "type": "string"},
-                },
-            },
-            "Body_update_item_items__item_id__put": {
-                "title": "Body_update_item_items__item_id__put",
-                "required": ["item", "user", "importance"],
-                "type": "object",
-                "properties": {
-                    "item": {"$ref": "#/components/schemas/Item"},
-                    "user": {"$ref": "#/components/schemas/User"},
-                    "importance": {"title": "Importance", "type": "integer"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-# Test required and embedded body parameters with no bodies sent
-@pytest.mark.parametrize(
-    "path,body,expected_status,expected_response",
-    [
-        (
-            "/items/5",
-            {
-                "importance": 2,
-                "item": {"name": "Foo", "price": 50.5},
-                "user": {"username": "Dave"},
-            },
-            200,
-            {
-                "item_id": 5,
-                "importance": 2,
-                "item": {
-                    "name": "Foo",
-                    "price": 50.5,
-                    "description": None,
-                    "tax": None,
-                },
-                "user": {"username": "Dave", "full_name": None},
-            },
-        ),
-        (
-            "/items/5",
-            None,
-            422,
-            {
-                "detail": [
-                    {
-                        "loc": ["body", "item"],
-                        "msg": "field required",
-                        "type": "value_error.missing",
-                    },
-                    {
-                        "loc": ["body", "user"],
-                        "msg": "field required",
-                        "type": "value_error.missing",
-                    },
-                    {
-                        "loc": ["body", "importance"],
-                        "msg": "field required",
-                        "type": "value_error.missing",
-                    },
-                ]
-            },
-        ),
-        (
-            "/items/5",
-            [],
-            422,
-            {
-                "detail": [
-                    {
-                        "loc": ["body", "item"],
-                        "msg": "field required",
-                        "type": "value_error.missing",
-                    },
-                    {
-                        "loc": ["body", "user"],
-                        "msg": "field required",
-                        "type": "value_error.missing",
-                    },
-                    {
-                        "loc": ["body", "importance"],
-                        "msg": "field required",
-                        "type": "value_error.missing",
-                    },
-                ]
-            },
-        ),
-    ],
-)
-def test_post_body(path, body, expected_status, expected_response):
-    response = client.put(path, json=body)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_body_nested_models/__init__.py b/tests/test_tutorial/test_body_nested_models/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_body_nested_models/test_tutorial009.py b/tests/test_tutorial/test_body_nested_models/test_tutorial009.py
deleted file mode 100644
index 2d8f329..0000000
--- a/tests/test_tutorial/test_body_nested_models/test_tutorial009.py
+++ /dev/null
@@ -1,103 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.body_nested_models.tutorial009 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/index-weights/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create Index Weights",
-                "operationId": "create_index_weights_index_weights__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {
-                                "title": "Weights",
-                                "type": "object",
-                                "additionalProperties": {"type": "number"},
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_post_body():
-    data = {"2": 2.2, "3": 3.3}
-    response = client.post("/index-weights/", json=data)
-    assert response.status_code == 200, response.text
-    assert response.json() == data
-
-
-def test_post_invalid_body():
-    data = {"foo": 2.2, "3": 3.3}
-    response = client.post("/index-weights/", json=data)
-    assert response.status_code == 422, response.text
-    assert response.json() == {
-        "detail": [
-            {
-                "loc": ["body", "__key__"],
-                "msg": "value is not a valid integer",
-                "type": "type_error.integer",
-            }
-        ]
-    }
diff --git a/tests/test_tutorial/test_body_updates/__init__.py b/tests/test_tutorial/test_body_updates/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_body_updates/test_tutorial001.py b/tests/test_tutorial/test_body_updates/test_tutorial001.py
deleted file mode 100644
index 86b58b9..0000000
--- a/tests/test_tutorial/test_body_updates/test_tutorial001.py
+++ /dev/null
@@ -1,161 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.body_updates.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Item"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Item",
-                "operationId": "read_item_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-            },
-            "put": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Item"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Update Item",
-                "operationId": "update_item_items__item_id__put",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/Item"}
-                        }
-                    },
-                    "required": True,
-                },
-            },
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "description": {"title": "Description", "type": "string"},
-                    "price": {"title": "Price", "type": "number"},
-                    "tax": {"title": "Tax", "type": "number", "default": 10.5},
-                    "tags": {
-                        "title": "Tags",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get():
-    response = client.get("/items/baz")
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "name": "Baz",
-        "description": None,
-        "price": 50.2,
-        "tax": 10.5,
-        "tags": [],
-    }
-
-
-def test_put():
-    response = client.put(
-        "/items/bar", json={"name": "Barz", "price": 3, "description": None}
-    )
-    assert response.json() == {
-        "name": "Barz",
-        "description": None,
-        "price": 3,
-        "tax": 10.5,
-        "tags": [],
-    }
diff --git a/tests/test_tutorial/test_conditional_openapi/__init__.py b/tests/test_tutorial/test_conditional_openapi/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_conditional_openapi/test_tutorial001.py b/tests/test_tutorial/test_conditional_openapi/test_tutorial001.py
deleted file mode 100644
index eee49a3..0000000
--- a/tests/test_tutorial/test_conditional_openapi/test_tutorial001.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import importlib
-
-from squall.testclient import TestClient
-
-from docs_src.conditional_openapi import tutorial001
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/": {
-            "get": {
-                "summary": "Root",
-                "operationId": "root__get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-            }
-        }
-    },
-}
-
-
-def test_default_openapi():
-    client = TestClient(tutorial001.app)
-    response = client.get("/openapi.json")
-    assert response.json() == openapi_schema
-    response = client.get("/docs")
-    assert response.status_code == 200, response.text
-    response = client.get("/redoc")
-    assert response.status_code == 200, response.text
-
-
-def test_disable_openapi(monkeypatch):
-    monkeypatch.setenv("OPENAPI_URL", "")
-    importlib.reload(tutorial001)
-    client = TestClient(tutorial001.app)
-    response = client.get("/openapi.json")
-    assert response.status_code == 404, response.text
-    response = client.get("/docs")
-    assert response.status_code == 404, response.text
-    response = client.get("/redoc")
-    assert response.status_code == 404, response.text
-
-
-def test_root():
-    client = TestClient(tutorial001.app)
-    response = client.get("/")
-    assert response.status_code == 200
-    assert response.json() == {"message": "Hello World"}
diff --git a/tests/test_tutorial/test_cookie_params/__init__.py b/tests/test_tutorial/test_cookie_params/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_cookie_params/test_tutorial001.py b/tests/test_tutorial/test_cookie_params/test_tutorial001.py
deleted file mode 100644
index f5186cf..0000000
--- a/tests/test_tutorial/test_cookie_params/test_tutorial001.py
+++ /dev/null
@@ -1,93 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.cookie_params.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {"title": "Ads Id", "type": "string"},
-                        "name": "ads_id",
-                        "in": "cookie",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-@pytest.mark.parametrize(
-    "path,cookies,expected_status,expected_response",
-    [
-        ("/openapi.json", None, 200, openapi_schema),
-        ("/items", None, 200, {"ads_id": None}),
-        ("/items", {"ads_id": "ads_track"}, 200, {"ads_id": "ads_track"}),
-        (
-            "/items",
-            {"ads_id": "ads_track", "session": "cookiesession"},
-            200,
-            {"ads_id": "ads_track"},
-        ),
-        ("/items", {"session": "cookiesession"}, 200, {"ads_id": None}),
-    ],
-)
-def test(path, cookies, expected_status, expected_response):
-    response = client.get(path, cookies=cookies)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_cors/__init__.py b/tests/test_tutorial/test_cors/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_cors/test_tutorial001.py b/tests/test_tutorial/test_cors/test_tutorial001.py
deleted file mode 100644
index 3331847..0000000
--- a/tests/test_tutorial/test_cors/test_tutorial001.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.cors.tutorial001 import app
-
-
-def test_cors():
-    client = TestClient(app)
-    # Test pre-flight response
-    headers = {
-        "Origin": "https://localhost.mtag.dev",
-        "Access-Control-Request-Method": "GET",
-        "Access-Control-Request-Headers": "X-Example",
-    }
-    response = client.options("/", headers=headers)
-    assert response.status_code == 200, response.text
-    assert response.text == "OK"
-    assert (
-        response.headers["access-control-allow-origin"] == "https://localhost.mtag.dev"
-    )
-    assert response.headers["access-control-allow-headers"] == "X-Example"
-
-    # Test standard response
-    headers = {"Origin": "https://localhost.mtag.dev"}
-    response = client.get("/", headers=headers)
-    assert response.status_code == 200, response.text
-    assert response.json() == {"message": "Hello World"}
-    assert (
-        response.headers["access-control-allow-origin"] == "https://localhost.mtag.dev"
-    )
-
-    # Test non-CORS response
-    response = client.get("/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"message": "Hello World"}
-    assert "access-control-allow-origin" not in response.headers
diff --git a/tests/test_tutorial/test_custom_request_and_route/__init__.py b/tests/test_tutorial/test_custom_request_and_route/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_custom_request_and_route/test_tutorial001.py b/tests/test_tutorial/test_custom_request_and_route/test_tutorial001.py
deleted file mode 100644
index 0d315a1..0000000
--- a/tests/test_tutorial/test_custom_request_and_route/test_tutorial001.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import gzip
-import json
-
-import pytest
-from squall import Request
-from squall.testclient import TestClient
-
-from docs_src.custom_request_and_route.tutorial001 import app
-
-
-@app.get("/check-class")
-async def check_gzip_request(request: Request):
-    return {"request_class": type(request).__name__}
-
-
-client = TestClient(app)
-
-
-@pytest.mark.parametrize("compress", [True, False])
-def test_gzip_request(compress):
-    n = 1000
-    headers = {}
-    body = [1] * n
-    data = json.dumps(body).encode()
-    if compress:
-        data = gzip.compress(data)
-        headers["Content-Encoding"] = "gzip"
-    headers["Content-Type"] = "application/json"
-    response = client.post("/sum", data=data, headers=headers)
-    assert response.json() == {"sum": n}
-
-
-def test_request_class():
-    response = client.get("/check-class")
-    assert response.json() == {"request_class": "GzipRequest"}
diff --git a/tests/test_tutorial/test_custom_request_and_route/test_tutorial002.py b/tests/test_tutorial/test_custom_request_and_route/test_tutorial002.py
deleted file mode 100644
index 4d85685..0000000
--- a/tests/test_tutorial/test_custom_request_and_route/test_tutorial002.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.custom_request_and_route.tutorial002 import app
-
-client = TestClient(app)
-
-
-def test_endpoint_works():
-    response = client.post("/", json=[1, 2, 3])
-    assert response.json() == 6
-
-
-def test_exception_handler_body_access():
-    response = client.post("/", json={"numbers": [1, 2, 3]})
-
-    assert response.json() == {
-        "detail": {
-            "body": '{"numbers": [1, 2, 3]}',
-            "errors": [
-                {
-                    "loc": ["body"],
-                    "msg": "value is not a valid list",
-                    "type": "type_error.list",
-                }
-            ],
-        }
-    }
diff --git a/tests/test_tutorial/test_custom_request_and_route/test_tutorial003.py b/tests/test_tutorial/test_custom_request_and_route/test_tutorial003.py
deleted file mode 100644
index 41f0e4c..0000000
--- a/tests/test_tutorial/test_custom_request_and_route/test_tutorial003.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.custom_request_and_route.tutorial003 import app
-
-client = TestClient(app)
-
-
-def test_get():
-    response = client.get("/")
-    assert response.json() == {"message": "Not timed"}
-    assert "X-Response-Time" not in response.headers
-
-
-def test_get_timed():
-    response = client.get("/timed")
-    assert response.json() == {"message": "It's the time of my life"}
-    assert "X-Response-Time" in response.headers
-    assert float(response.headers["X-Response-Time"]) >= 0
diff --git a/tests/test_tutorial/test_custom_response/__init__.py b/tests/test_tutorial/test_custom_response/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial001b.py b/tests/test_tutorial/test_custom_response/test_tutorial001b.py
deleted file mode 100644
index c27fcc9..0000000
--- a/tests/test_tutorial/test_custom_response/test_tutorial001b.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.custom_response.tutorial001b import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get_custom_response():
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    assert response.json() == [{"item_id": "Foo"}]
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial004.py b/tests/test_tutorial/test_custom_response/test_tutorial004.py
deleted file mode 100644
index c23aba8..0000000
--- a/tests/test_tutorial/test_custom_response/test_tutorial004.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.custom_response.tutorial004 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"text/html": {"schema": {"type": "string"}}},
-                    }
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-            }
-        }
-    },
-}
-
-html_contents = """
-    <html>
-        <head>
-            <title>Some HTML in here</title>
-        </head>
-        <body>
-            <h1>Look ma! HTML!</h1>
-        </body>
-    </html>
-    """
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get_custom_response():
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    assert response.text == html_contents
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial005.py b/tests/test_tutorial/test_custom_response/test_tutorial005.py
deleted file mode 100644
index 32ae663..0000000
--- a/tests/test_tutorial/test_custom_response/test_tutorial005.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.custom_response.tutorial005 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/": {
-            "get": {
-                "summary": "Main",
-                "operationId": "main__get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"text/plain": {"schema": {"type": "string"}}},
-                    }
-                },
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get():
-    response = client.get("/")
-    assert response.status_code == 200, response.text
-    assert response.text == "Hello World"
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial006.py b/tests/test_tutorial/test_custom_response/test_tutorial006.py
deleted file mode 100644
index 7eab403..0000000
--- a/tests/test_tutorial/test_custom_response/test_tutorial006.py
+++ /dev/null
@@ -1,37 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.custom_response.tutorial006 import app
-
-client = TestClient(app)
-
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/subdomain": {
-            "get": {
-                "summary": "Redirect Typer",
-                "operationId": "redirect_typer_subdomain_get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get():
-    response = client.get("/subdomain", allow_redirects=False)
-    assert response.status_code == 307, response.text
-    assert response.headers["location"] == "https://subdomain.example.com"
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial006b.py b/tests/test_tutorial/test_custom_response/test_tutorial006b.py
deleted file mode 100644
index 62a8ed9..0000000
--- a/tests/test_tutorial/test_custom_response/test_tutorial006b.py
+++ /dev/null
@@ -1,34 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.custom_response.tutorial006b import app
-
-client = TestClient(app)
-
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.0.1"},
-    "paths": {
-        "/squall": {
-            "get": {
-                "summary": "Redirect Squall",
-                "operationId": "redirect_squall_squall_get",
-                "responses": {"307": {"description": "Successful Response"}},
-            }
-        }
-    },
-}
-
-
-@pytest.mark.skip("fix")
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_redirect_response_class():
-    response = client.get("/squall", allow_redirects=False)
-    assert response.status_code == 307
-    assert response.headers["location"] == "https://squall.mtag.dev"
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial006c.py b/tests/test_tutorial/test_custom_response/test_tutorial006c.py
deleted file mode 100644
index a595153..0000000
--- a/tests/test_tutorial/test_custom_response/test_tutorial006c.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.custom_response.tutorial006c import app
-
-client = TestClient(app)
-
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/pydantic": {
-            "get": {
-                "summary": "Redirect Pydantic",
-                "operationId": "redirect_pydantic_pydantic_get",
-                "responses": {"302": {"description": "Successful Response"}},
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_redirect_status_code():
-    response = client.get("/pydantic", allow_redirects=False)
-    assert response.status_code == 302
-    assert response.headers["location"] == "https://pydantic-docs.helpmanual.io/"
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial007.py b/tests/test_tutorial/test_custom_response/test_tutorial007.py
deleted file mode 100644
index 3ebd0a3..0000000
--- a/tests/test_tutorial/test_custom_response/test_tutorial007.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.custom_response.tutorial007 import app
-
-client = TestClient(app)
-
-
-def test_get():
-    fake_content = b"some fake video bytes"
-    response = client.get("/")
-    assert response.content == fake_content * 10
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial008.py b/tests/test_tutorial/test_custom_response/test_tutorial008.py
deleted file mode 100644
index 21d0d74..0000000
--- a/tests/test_tutorial/test_custom_response/test_tutorial008.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from pathlib import Path
-
-from squall.testclient import TestClient
-
-from docs_src.custom_response import tutorial008
-from docs_src.custom_response.tutorial008 import app
-
-client = TestClient(app)
-
-
-def test_get(tmp_path: Path):
-    file_path: Path = tmp_path / "large-video-file.mp4"
-    tutorial008.some_file_path = str(file_path)
-    test_content = b"Fake video bytes"
-    file_path.write_bytes(test_content)
-    response = client.get("/")
-    assert response.content == test_content
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial009.py b/tests/test_tutorial/test_custom_response/test_tutorial009.py
deleted file mode 100644
index a4bd562..0000000
--- a/tests/test_tutorial/test_custom_response/test_tutorial009.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from pathlib import Path
-
-from squall.testclient import TestClient
-
-from docs_src.custom_response import tutorial009
-from docs_src.custom_response.tutorial009 import app
-
-client = TestClient(app)
-
-
-def test_get(tmp_path: Path):
-    file_path: Path = tmp_path / "large-video-file.mp4"
-    tutorial009.some_file_path = str(file_path)
-    test_content = b"Fake video bytes"
-    file_path.write_bytes(test_content)
-    response = client.get("/")
-    assert response.content == test_content
diff --git a/tests/test_tutorial/test_custom_response/test_tutorial009b.py b/tests/test_tutorial/test_custom_response/test_tutorial009b.py
deleted file mode 100644
index 3696e83..0000000
--- a/tests/test_tutorial/test_custom_response/test_tutorial009b.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from pathlib import Path
-
-from squall.testclient import TestClient
-
-from docs_src.custom_response import tutorial009b
-from docs_src.custom_response.tutorial009b import app
-
-client = TestClient(app)
-
-
-def test_get(tmp_path: Path):
-    file_path: Path = tmp_path / "large-video-file.mp4"
-    tutorial009b.some_file_path = str(file_path)
-    test_content = b"Fake video bytes"
-    file_path.write_bytes(test_content)
-    response = client.get("/")
-    assert response.content == test_content
diff --git a/tests/test_tutorial/test_dataclasses/test_tutorial001.py b/tests/test_tutorial/test_dataclasses/test_tutorial001.py
deleted file mode 100644
index c21126f..0000000
--- a/tests/test_tutorial/test_dataclasses/test_tutorial001.py
+++ /dev/null
@@ -1,113 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.dataclasses.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "post": {
-                "summary": "Create Item",
-                "operationId": "create_item_items__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/Item"}
-                        }
-                    },
-                    "required": True,
-                },
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-            "Item": {
-                "title": "Item",
-                "required": ["name", "price"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "price": {"title": "Price", "type": "number"},
-                    "description": {"title": "Description", "type": "string"},
-                    "tax": {"title": "Tax", "type": "number"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200
-    assert response.json() == openapi_schema
-
-
-def test_post_item():
-    response = client.post("/items/", json={"name": "Foo", "price": 3})
-    assert response.status_code == 200
-    assert response.json() == {
-        "name": "Foo",
-        "price": 3,
-        "description": None,
-        "tax": None,
-    }
-
-
-def test_post_invalid_item():
-    response = client.post("/items/", json={"name": "Foo", "price": "invalid price"})
-    assert response.status_code == 422
-    assert response.json() == {
-        "detail": [
-            {
-                "loc": ["body", "price"],
-                "msg": "value is not a valid float",
-                "type": "type_error.float",
-            }
-        ]
-    }
diff --git a/tests/test_tutorial/test_dataclasses/test_tutorial002.py b/tests/test_tutorial/test_dataclasses/test_tutorial002.py
deleted file mode 100644
index ccea259..0000000
--- a/tests/test_tutorial/test_dataclasses/test_tutorial002.py
+++ /dev/null
@@ -1,66 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.dataclasses.tutorial002 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/next": {
-            "get": {
-                "summary": "Read Next Item",
-                "operationId": "read_next_item_items_next_get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Item"}
-                            }
-                        },
-                    }
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "required": ["name", "price", "tags"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "price": {"title": "Price", "type": "number"},
-                    "tags": {
-                        "title": "Tags",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "description": {"title": "Description", "type": "string"},
-                    "tax": {"title": "Tax", "type": "number"},
-                },
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200
-    assert response.json() == openapi_schema
-
-
-def test_get_item():
-    response = client.get("/items/next")
-    assert response.status_code == 200
-    assert response.json() == {
-        "name": "Island In The Moon",
-        "price": 12.99,
-        "description": "A place to be be playin' and havin' fun",
-        "tags": ["breater"],
-        "tax": None,
-    }
diff --git a/tests/test_tutorial/test_dataclasses/test_tutorial003.py b/tests/test_tutorial/test_dataclasses/test_tutorial003.py
deleted file mode 100644
index 5392aa9..0000000
--- a/tests/test_tutorial/test_dataclasses/test_tutorial003.py
+++ /dev/null
@@ -1,181 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.dataclasses.tutorial003 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/authors/{author_id}/items/": {
-            "post": {
-                "summary": "Create Author Items",
-                "operationId": "create_author_items_authors__author_id__items__post",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Author Id", "type": "string"},
-                        "name": "author_id",
-                        "in": "path",
-                    }
-                ],
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {
-                                "title": "Items",
-                                "type": "array",
-                                "items": {"$ref": "#/components/schemas/Item"},
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Author"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-        "/authors/": {
-            "get": {
-                "summary": "Get Authors",
-                "operationId": "get_authors_authors__get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "title": "Response Get Authors Authors  Get",
-                                    "type": "array",
-                                    "items": {"$ref": "#/components/schemas/Author"},
-                                }
-                            }
-                        },
-                    }
-                },
-            }
-        },
-    },
-    "components": {
-        "schemas": {
-            "Author": {
-                "title": "Author",
-                "required": ["name"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "items": {
-                        "title": "Items",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/Item"},
-                    },
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-            "Item": {
-                "title": "Item",
-                "required": ["name"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "description": {"title": "Description", "type": "string"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200
-    assert response.json() == openapi_schema
-
-
-def test_post_authors_item():
-    response = client.post(
-        "/authors/foo/items/",
-        json=[{"name": "Bar"}, {"name": "Baz", "description": "Drop the Baz"}],
-    )
-    assert response.status_code == 200
-    assert response.json() == {
-        "name": "foo",
-        "items": [
-            {"name": "Bar", "description": None},
-            {"name": "Baz", "description": "Drop the Baz"},
-        ],
-    }
-
-
-def test_get_authors():
-    response = client.get("/authors/")
-    assert response.status_code == 200
-    assert response.json() == [
-        {
-            "name": "Breaters",
-            "items": [
-                {
-                    "name": "Island In The Moon",
-                    "description": "A place to be be playin' and havin' fun",
-                },
-                {"name": "Holy Buddies", "description": None},
-            ],
-        },
-        {
-            "name": "System of an Up",
-            "items": [
-                {
-                    "name": "Salt",
-                    "description": "The kombucha mushroom people's favorite",
-                },
-                {"name": "Pad Thai", "description": None},
-                {
-                    "name": "Lonely Night",
-                    "description": "The mostests lonliest nightiest of allest",
-                },
-            ],
-        },
-    ]
diff --git a/tests/test_tutorial/test_dependencies/__init__.py b/tests/test_tutorial/test_dependencies/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_dependencies/test_tutorial001.py b/tests/test_tutorial/test_dependencies/test_tutorial001.py
deleted file mode 100644
index 59da8df..0000000
--- a/tests/test_tutorial/test_dependencies/test_tutorial001.py
+++ /dev/null
@@ -1,149 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.dependencies.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {"title": "Q", "type": "string"},
-                        "name": "q",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Skip", "type": "integer", "default": 0},
-                        "name": "skip",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Limit", "type": "integer", "default": 100},
-                        "name": "limit",
-                        "in": "query",
-                    },
-                ],
-            }
-        },
-        "/users/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Users",
-                "operationId": "read_users_users__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {"title": "Q", "type": "string"},
-                        "name": "q",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Skip", "type": "integer", "default": 0},
-                        "name": "skip",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Limit", "type": "integer", "default": 100},
-                        "name": "limit",
-                        "in": "query",
-                    },
-                ],
-            }
-        },
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-@pytest.mark.parametrize(
-    "path,expected_status,expected_response",
-    [
-        ("/items", 200, {"q": None, "skip": 0, "limit": 100}),
-        ("/items?q=foo", 200, {"q": "foo", "skip": 0, "limit": 100}),
-        ("/items?q=foo&skip=5", 200, {"q": "foo", "skip": 5, "limit": 100}),
-        ("/items?q=foo&skip=5&limit=30", 200, {"q": "foo", "skip": 5, "limit": 30}),
-        ("/users", 200, {"q": None, "skip": 0, "limit": 100}),
-        ("/openapi.json", 200, openapi_schema),
-    ],
-)
-def test_get(path, expected_status, expected_response):
-    response = client.get(path)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_dependencies/test_tutorial004.py b/tests/test_tutorial/test_dependencies/test_tutorial004.py
deleted file mode 100644
index af294b3..0000000
--- a/tests/test_tutorial/test_dependencies/test_tutorial004.py
+++ /dev/null
@@ -1,144 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.dependencies.tutorial004 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {"title": "Q", "type": "string"},
-                        "name": "q",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Skip", "type": "integer", "default": 0},
-                        "name": "skip",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Limit", "type": "integer", "default": 100},
-                        "name": "limit",
-                        "in": "query",
-                    },
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-@pytest.mark.parametrize(
-    "path,expected_status,expected_response",
-    [
-        (
-            "/items",
-            200,
-            {
-                "items": [
-                    {"item_name": "Foo"},
-                    {"item_name": "Bar"},
-                    {"item_name": "Baz"},
-                ]
-            },
-        ),
-        (
-            "/items?q=foo",
-            200,
-            {
-                "items": [
-                    {"item_name": "Foo"},
-                    {"item_name": "Bar"},
-                    {"item_name": "Baz"},
-                ],
-                "q": "foo",
-            },
-        ),
-        (
-            "/items?q=foo&skip=1",
-            200,
-            {"items": [{"item_name": "Bar"}, {"item_name": "Baz"}], "q": "foo"},
-        ),
-        (
-            "/items?q=bar&limit=2",
-            200,
-            {"items": [{"item_name": "Foo"}, {"item_name": "Bar"}], "q": "bar"},
-        ),
-        (
-            "/items?q=bar&skip=1&limit=1",
-            200,
-            {"items": [{"item_name": "Bar"}], "q": "bar"},
-        ),
-        (
-            "/items?limit=1&q=bar&skip=1",
-            200,
-            {"items": [{"item_name": "Bar"}], "q": "bar"},
-        ),
-    ],
-)
-def test_get(path, expected_status, expected_response):
-    response = client.get(path)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_dependencies/test_tutorial006.py b/tests/test_tutorial/test_dependencies/test_tutorial006.py
deleted file mode 100644
index 177af6c..0000000
--- a/tests/test_tutorial/test_dependencies/test_tutorial006.py
+++ /dev/null
@@ -1,128 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.dependencies.tutorial006 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "X-Token", "type": "string"},
-                        "name": "x-token",
-                        "in": "header",
-                    },
-                    {
-                        "required": True,
-                        "schema": {"title": "X-Key", "type": "string"},
-                        "name": "x-key",
-                        "in": "header",
-                    },
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get_no_headers():
-    response = client.get("/items/")
-    assert response.status_code == 422, response.text
-    assert response.json() == {
-        "detail": [
-            {
-                "loc": ["header", "x-token"],
-                "msg": "field required",
-                "type": "value_error.missing",
-            },
-            {
-                "loc": ["header", "x-key"],
-                "msg": "field required",
-                "type": "value_error.missing",
-            },
-        ]
-    }
-
-
-def test_get_invalid_one_header():
-    response = client.get("/items/", headers={"X-Token": "invalid"})
-    assert response.status_code == 400, response.text
-    assert response.json() == {"detail": "X-Token header invalid"}
-
-
-def test_get_invalid_second_header():
-    response = client.get(
-        "/items/", headers={"X-Token": "fake-super-secret-token", "X-Key": "invalid"}
-    )
-    assert response.status_code == 400, response.text
-    assert response.json() == {"detail": "X-Key header invalid"}
-
-
-def test_get_valid_headers():
-    response = client.get(
-        "/items/",
-        headers={
-            "X-Token": "fake-super-secret-token",
-            "X-Key": "fake-super-secret-key",
-        },
-    )
-    assert response.status_code == 200, response.text
-    assert response.json() == [{"item": "Foo"}, {"item": "Bar"}]
diff --git a/tests/test_tutorial/test_dependencies/test_tutorial012.py b/tests/test_tutorial/test_dependencies/test_tutorial012.py
deleted file mode 100644
index 021bf78..0000000
--- a/tests/test_tutorial/test_dependencies/test_tutorial012.py
+++ /dev/null
@@ -1,211 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.dependencies.tutorial012 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "X-Token", "type": "string"},
-                        "name": "x-token",
-                        "in": "header",
-                    },
-                    {
-                        "required": True,
-                        "schema": {"title": "X-Key", "type": "string"},
-                        "name": "x-key",
-                        "in": "header",
-                    },
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-        "/users/": {
-            "get": {
-                "summary": "Read Users",
-                "operationId": "read_users_users__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "X-Token", "type": "string"},
-                        "name": "x-token",
-                        "in": "header",
-                    },
-                    {
-                        "required": True,
-                        "schema": {"title": "X-Key", "type": "string"},
-                        "name": "x-key",
-                        "in": "header",
-                    },
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-    },
-    "components": {
-        "schemas": {
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-        }
-    },
-}
-
-
-@pytest.mark.skip(reason="SQUALL-20")
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get_no_headers_items():
-    response = client.get("/items/")
-    assert response.status_code == 422, response.text
-    assert response.json() == {
-        "detail": [
-            {
-                "loc": ["header", "x-token"],
-                "msg": "field required",
-                "type": "value_error.missing",
-            },
-            {
-                "loc": ["header", "x-key"],
-                "msg": "field required",
-                "type": "value_error.missing",
-            },
-        ]
-    }
-
-
-def test_get_no_headers_users():
-    response = client.get("/users/")
-    assert response.status_code == 422, response.text
-    assert response.json() == {
-        "detail": [
-            {
-                "loc": ["header", "x-token"],
-                "msg": "field required",
-                "type": "value_error.missing",
-            },
-            {
-                "loc": ["header", "x-key"],
-                "msg": "field required",
-                "type": "value_error.missing",
-            },
-        ]
-    }
-
-
-def test_get_invalid_one_header_items():
-    response = client.get("/items/", headers={"X-Token": "invalid"})
-    assert response.status_code == 400, response.text
-    assert response.json() == {"detail": "X-Token header invalid"}
-
-
-def test_get_invalid_one_users():
-    response = client.get("/users/", headers={"X-Token": "invalid"})
-    assert response.status_code == 400, response.text
-    assert response.json() == {"detail": "X-Token header invalid"}
-
-
-def test_get_invalid_second_header_items():
-    response = client.get(
-        "/items/", headers={"X-Token": "fake-super-secret-token", "X-Key": "invalid"}
-    )
-    assert response.status_code == 400, response.text
-    assert response.json() == {"detail": "X-Key header invalid"}
-
-
-def test_get_invalid_second_header_users():
-    response = client.get(
-        "/users/", headers={"X-Token": "fake-super-secret-token", "X-Key": "invalid"}
-    )
-    assert response.status_code == 400, response.text
-    assert response.json() == {"detail": "X-Key header invalid"}
-
-
-def test_get_valid_headers_items():
-    response = client.get(
-        "/items/",
-        headers={
-            "X-Token": "fake-super-secret-token",
-            "X-Key": "fake-super-secret-key",
-        },
-    )
-    assert response.status_code == 200, response.text
-    assert response.json() == [{"item": "Portal Gun"}, {"item": "Plumbus"}]
-
-
-def test_get_valid_headers_users():
-    response = client.get(
-        "/users/",
-        headers={
-            "X-Token": "fake-super-secret-token",
-            "X-Key": "fake-super-secret-key",
-        },
-    )
-    assert response.status_code == 200, response.text
-    assert response.json() == [{"username": "Rick"}, {"username": "Morty"}]
diff --git a/tests/test_tutorial/test_events/__init__.py b/tests/test_tutorial/test_events/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_events/test_tutorial001.py b/tests/test_tutorial/test_events/test_tutorial001.py
deleted file mode 100644
index f64afe1..0000000
--- a/tests/test_tutorial/test_events/test_tutorial001.py
+++ /dev/null
@@ -1,79 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.events.tutorial001 import app
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_events():
-    with TestClient(app) as client:
-        response = client.get("/openapi.json")
-        assert response.status_code == 200, response.text
-        assert response.json() == openapi_schema
-        response = client.get("/items/foo")
-        assert response.status_code == 200, response.text
-        assert response.json() == {"name": "Fighters"}
diff --git a/tests/test_tutorial/test_events/test_tutorial002.py b/tests/test_tutorial/test_events/test_tutorial002.py
deleted file mode 100644
index de9c6aa..0000000
--- a/tests/test_tutorial/test_events/test_tutorial002.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.events.tutorial002 import app
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-            }
-        }
-    },
-}
-
-
-def test_events():
-    with TestClient(app) as client:
-        response = client.get("/openapi.json")
-        assert response.status_code == 200, response.text
-        assert response.json() == openapi_schema
-        response = client.get("/items/")
-        assert response.status_code == 200, response.text
-        assert response.json() == [{"name": "Foo"}]
-    with open("log.txt") as log:
-        assert "Application shutdown" in log.read()
diff --git a/tests/test_tutorial/test_extending_openapi/__init__.py b/tests/test_tutorial/test_extending_openapi/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_extending_openapi/test_tutorial001.py b/tests/test_tutorial/test_extending_openapi/test_tutorial001.py
deleted file mode 100644
index fa88dcf..0000000
--- a/tests/test_tutorial/test_extending_openapi/test_tutorial001.py
+++ /dev/null
@@ -1,44 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.extending_openapi.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {
-        "title": "Custom title",
-        "version": "2.5.0",
-        "description": "This is a very custom OpenAPI schema",
-        "logo": {"url": "https://squall.mtag.dev/img/logo-margin/logo-teal.png"},
-    },
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test():
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    assert response.json() == [{"name": "Foo"}]
diff --git a/tests/test_tutorial/test_extending_openapi/test_tutorial002.py b/tests/test_tutorial/test_extending_openapi/test_tutorial002.py
deleted file mode 100644
index bb9feba..0000000
--- a/tests/test_tutorial/test_extending_openapi/test_tutorial002.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import os
-from pathlib import Path
-
-import pytest
-from squall.testclient import TestClient
-
-
-@pytest.fixture(scope="module")
-def client():
-    static_dir: Path = Path(os.getcwd()) / "static"
-    print(static_dir)
-    static_dir.mkdir(exist_ok=True)
-    from docs_src.extending_openapi.tutorial002 import app
-
-    with TestClient(app) as client:
-        yield client
-
-
-def test_swagger_ui_html(client: TestClient):
-    response = client.get("/docs")
-    assert response.status_code == 200, response.text
-    assert "/static/swagger-ui-bundle.js" in response.text
-    assert "/static/swagger-ui.css" in response.text
-
-
-def test_swagger_ui_oauth2_redirect_html(client: TestClient):
-    response = client.get("/docs/oauth2-redirect")
-    assert response.status_code == 200, response.text
-    assert "window.opener.swaggerUIRedirectOauth2" in response.text
-
-
-def test_redoc_html(client: TestClient):
-    response = client.get("/redoc")
-    assert response.status_code == 200, response.text
-    assert "/static/redoc.standalone.js" in response.text
-
-
-def test_api(client: TestClient):
-    response = client.get("/users/john")
-    assert response.status_code == 200, response.text
-    assert response.json()["message"] == "Hello john"
diff --git a/tests/test_tutorial/test_extra_data_types/__init__.py b/tests/test_tutorial/test_extra_data_types/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_extra_data_types/test_tutorial001.py b/tests/test_tutorial/test_extra_data_types/test_tutorial001.py
deleted file mode 100644
index af17c68..0000000
--- a/tests/test_tutorial/test_extra_data_types/test_tutorial001.py
+++ /dev/null
@@ -1,131 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.extra_data_types.tutorial001 import app
-
-client = TestClient(app)
-
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "put": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__item_id__put",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {
-                            "title": "Item Id",
-                            "type": "string",
-                            "format": "uuid",
-                        },
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {
-                                "$ref": "#/components/schemas/Body_read_items_items__item_id__put"
-                            }
-                        }
-                    }
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Body_read_items_items__item_id__put": {
-                "title": "Body_read_items_items__item_id__put",
-                "type": "object",
-                "properties": {
-                    "start_datetime": {
-                        "title": "Start Datetime",
-                        "type": "string",
-                        "format": "date-time",
-                    },
-                    "end_datetime": {
-                        "title": "End Datetime",
-                        "type": "string",
-                        "format": "date-time",
-                    },
-                    "repeat_at": {
-                        "title": "Repeat At",
-                        "type": "string",
-                        "format": "time",
-                    },
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_extra_types():
-    item_id = "ff97dd87-a4a5-4a12-b412-cde99f33e00e"
-    data = {
-        "start_datetime": "2018-12-22T14:00:00+00:00",
-        "end_datetime": "2018-12-24T15:00:00+00:00",
-        "repeat_at": "15:30:00",
-    }
-    expected_response = data.copy()
-    expected_response.update(
-        {
-            "start_process": "2018-12-22T14:00:00+00:00",
-            "item_id": item_id,
-        }
-    )
-    response = client.put(f"/items/{item_id}", json=data)
-    assert response.status_code == 200, response.text
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_extra_models/__init__.py b/tests/test_tutorial/test_extra_models/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_extra_models/test_tutorial003.py b/tests/test_tutorial/test_extra_models/test_tutorial003.py
deleted file mode 100644
index 02138d2..0000000
--- a/tests/test_tutorial/test_extra_models/test_tutorial003.py
+++ /dev/null
@@ -1,125 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.extra_models.tutorial003 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "title": "Response Read Item Items  Item Id  Get",
-                                    "anyOf": [
-                                        {"$ref": "#/components/schemas/PlaneItem"},
-                                        {"$ref": "#/components/schemas/CarItem"},
-                                    ],
-                                }
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Item",
-                "operationId": "read_item_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "PlaneItem": {
-                "title": "PlaneItem",
-                "required": ["description", "size"],
-                "type": "object",
-                "properties": {
-                    "description": {"title": "Description", "type": "string"},
-                    "type": {"title": "Type", "type": "string", "default": "plane"},
-                    "size": {"title": "Size", "type": "integer"},
-                },
-            },
-            "CarItem": {
-                "title": "CarItem",
-                "required": ["description"],
-                "type": "object",
-                "properties": {
-                    "description": {"title": "Description", "type": "string"},
-                    "type": {"title": "Type", "type": "string", "default": "car"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get_car():
-    response = client.get("/items/item1")
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "description": "All my friends drive a low rider",
-        "type": "car",
-    }
-
-
-def test_get_plane():
-    response = client.get("/items/item2")
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "description": "Music is my aeroplane, it's my aeroplane",
-        "type": "plane",
-        "size": 5,
-    }
diff --git a/tests/test_tutorial/test_extra_models/test_tutorial004.py b/tests/test_tutorial/test_extra_models/test_tutorial004.py
deleted file mode 100644
index 0925b74..0000000
--- a/tests/test_tutorial/test_extra_models/test_tutorial004.py
+++ /dev/null
@@ -1,60 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.extra_models.tutorial004 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "title": "Response Read Items Items  Get",
-                                    "type": "array",
-                                    "items": {"$ref": "#/components/schemas/Item"},
-                                }
-                            }
-                        },
-                    }
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "required": ["name", "description"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "description": {"title": "Description", "type": "string"},
-                },
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get_items():
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    assert response.json() == [
-        {"name": "Foo", "description": "There comes my hero"},
-        {"name": "Red", "description": "It's my aeroplane"},
-    ]
diff --git a/tests/test_tutorial/test_extra_models/test_tutorial005.py b/tests/test_tutorial/test_extra_models/test_tutorial005.py
deleted file mode 100644
index d8e00d6..0000000
--- a/tests/test_tutorial/test_extra_models/test_tutorial005.py
+++ /dev/null
@@ -1,44 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.extra_models.tutorial005 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/keyword-weights/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "title": "Response Read Keyword Weights Keyword Weights  Get",
-                                    "type": "object",
-                                    "additionalProperties": {"type": "number"},
-                                }
-                            }
-                        },
-                    }
-                },
-                "summary": "Read Keyword Weights",
-                "operationId": "read_keyword_weights_keyword_weights__get",
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get_items():
-    response = client.get("/keyword-weights/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"foo": 2.3, "bar": 3.4}
diff --git a/tests/test_tutorial/test_first_steps/__init__.py b/tests/test_tutorial/test_first_steps/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_first_steps/test_tutorial001.py b/tests/test_tutorial/test_first_steps/test_tutorial001.py
deleted file mode 100644
index 88f9477..0000000
--- a/tests/test_tutorial/test_first_steps/test_tutorial001.py
+++ /dev/null
@@ -1,39 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.first_steps.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "summary": "Root",
-                "operationId": "root__get",
-            }
-        }
-    },
-}
-
-
-@pytest.mark.parametrize(
-    "path,expected_status,expected_response",
-    [
-        ("/", 200, {"message": "Hello World"}),
-        ("/nonexistent", 404, {"detail": "Not Found"}),
-        ("/openapi.json", 200, openapi_schema),
-    ],
-)
-def test_get_path(path, expected_status, expected_response):
-    response = client.get(path)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_handling_errors/__init__.py b/tests/test_tutorial/test_handling_errors/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_handling_errors/test_tutorial001.py b/tests/test_tutorial/test_handling_errors/test_tutorial001.py
deleted file mode 100644
index 394afc8..0000000
--- a/tests/test_tutorial/test_handling_errors/test_tutorial001.py
+++ /dev/null
@@ -1,90 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.handling_errors.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Item",
-                "operationId": "read_item_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get_item():
-    response = client.get("/items/foo")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"item": "The Foo Wrestlers"}
-
-
-def test_get_item_not_found():
-    response = client.get("/items/bar")
-    assert response.status_code == 404, response.text
-    assert response.headers.get("x-error") is None
-    assert response.json() == {"detail": "Item not found"}
diff --git a/tests/test_tutorial/test_handling_errors/test_tutorial002.py b/tests/test_tutorial/test_handling_errors/test_tutorial002.py
deleted file mode 100644
index 7d83f97..0000000
--- a/tests/test_tutorial/test_handling_errors/test_tutorial002.py
+++ /dev/null
@@ -1,90 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.handling_errors.tutorial002 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items-header/{item_id}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Item Header",
-                "operationId": "read_item_header_items_header__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get_item_header():
-    response = client.get("/items-header/foo")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"item": "The Foo Wrestlers"}
-
-
-def test_get_item_not_found_header():
-    response = client.get("/items-header/bar")
-    assert response.status_code == 404, response.text
-    assert response.headers.get("x-error") == "There goes my error"
-    assert response.json() == {"detail": "Item not found"}
diff --git a/tests/test_tutorial/test_handling_errors/test_tutorial003.py b/tests/test_tutorial/test_handling_errors/test_tutorial003.py
deleted file mode 100644
index 166006c..0000000
--- a/tests/test_tutorial/test_handling_errors/test_tutorial003.py
+++ /dev/null
@@ -1,91 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.handling_errors.tutorial003 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/unicorns/{name}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Unicorn",
-                "operationId": "read_unicorn_unicorns__name__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Name", "type": "string"},
-                        "name": "name",
-                        "in": "path",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get():
-    response = client.get("/unicorns/shinny")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"unicorn_name": "shinny"}
-
-
-def test_get_exception():
-    response = client.get("/unicorns/yolo")
-    assert response.status_code == 418, response.text
-    assert response.json() == {
-        "message": "Oops! yolo did something. There goes a rainbow..."
-    }
diff --git a/tests/test_tutorial/test_handling_errors/test_tutorial004.py b/tests/test_tutorial/test_handling_errors/test_tutorial004.py
deleted file mode 100644
index 47eafe6..0000000
--- a/tests/test_tutorial/test_handling_errors/test_tutorial004.py
+++ /dev/null
@@ -1,100 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.handling_errors.tutorial004 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Item",
-                "operationId": "read_item_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "integer"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get_validation_error():
-    response = client.get("/items/foo")
-    assert response.status_code == 400, response.text
-    validation_error_str_lines = [
-        b"1 validation error for Request",
-        b"path -> item_id",
-        b"  value is not a valid integer (type=type_error.integer)",
-    ]
-    assert response.content == b"\n".join(validation_error_str_lines)
-
-
-def test_get_http_error():
-    response = client.get("/items/3")
-    assert response.status_code == 418, response.text
-    assert response.content == b"Nope! I don't like 3."
-
-
-def test_get():
-    response = client.get("/items/2")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"item_id": 2}
diff --git a/tests/test_tutorial/test_handling_errors/test_tutorial005.py b/tests/test_tutorial/test_handling_errors/test_tutorial005.py
deleted file mode 100644
index 4b99810..0000000
--- a/tests/test_tutorial/test_handling_errors/test_tutorial005.py
+++ /dev/null
@@ -1,108 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.handling_errors.tutorial005 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "post": {
-                "summary": "Create Item",
-                "operationId": "create_item_items__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/Item"}
-                        }
-                    },
-                    "required": True,
-                },
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-            "Item": {
-                "title": "Item",
-                "required": ["title", "size"],
-                "type": "object",
-                "properties": {
-                    "title": {"title": "Title", "type": "string"},
-                    "size": {"title": "Size", "type": "integer"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_post_validation_error():
-    response = client.post("/items/", json={"title": "towel", "size": "XL"})
-    assert response.status_code == 422, response.text
-    assert response.json() == {
-        "detail": [
-            {
-                "loc": ["body", "size"],
-                "msg": "value is not a valid integer",
-                "type": "type_error.integer",
-            }
-        ],
-        "body": {"title": "towel", "size": "XL"},
-    }
-
-
-def test_post():
-    data = {"title": "towel", "size": 5}
-    response = client.post("/items/", json=data)
-    assert response.status_code == 200, response.text
-    assert response.json() == data
diff --git a/tests/test_tutorial/test_handling_errors/test_tutorial006.py b/tests/test_tutorial/test_handling_errors/test_tutorial006.py
deleted file mode 100644
index 24abbbd..0000000
--- a/tests/test_tutorial/test_handling_errors/test_tutorial006.py
+++ /dev/null
@@ -1,103 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.handling_errors.tutorial006 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Item",
-                "operationId": "read_item_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "integer"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get_validation_error():
-    response = client.get("/items/foo")
-    assert response.status_code == 422, response.text
-    assert response.json() == {
-        "detail": [
-            {
-                "loc": ["path", "item_id"],
-                "msg": "value is not a valid integer",
-                "type": "type_error.integer",
-            }
-        ]
-    }
-
-
-def test_get_http_error():
-    response = client.get("/items/3")
-    assert response.status_code == 418, response.text
-    assert response.json() == {"detail": "Nope! I don't like 3."}
-
-
-def test_get():
-    response = client.get("/items/2")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"item_id": 2}
diff --git a/tests/test_tutorial/test_header_params/__init__.py b/tests/test_tutorial/test_header_params/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_header_params/test_tutorial001.py b/tests/test_tutorial/test_header_params/test_tutorial001.py
deleted file mode 100644
index e42392f..0000000
--- a/tests/test_tutorial/test_header_params/test_tutorial001.py
+++ /dev/null
@@ -1,88 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.header_params.tutorial001 import app
-
-client = TestClient(app)
-
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {"title": "User-Agent", "type": "string"},
-                        "name": "user-agent",
-                        "in": "header",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-@pytest.mark.parametrize(
-    "path,headers,expected_status,expected_response",
-    [
-        ("/openapi.json", None, 200, openapi_schema),
-        ("/items", None, 200, {"User-Agent": "testclient"}),
-        ("/items", {"X-Header": "notvalid"}, 200, {"User-Agent": "testclient"}),
-        ("/items", {"User-Agent": "Squall test"}, 200, {"User-Agent": "Squall test"}),
-    ],
-)
-def test(path, headers, expected_status, expected_response):
-    response = client.get(path, headers=headers)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_metadata/__init__.py b/tests/test_tutorial/test_metadata/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_metadata/test_tutorial001.py b/tests/test_tutorial/test_metadata/test_tutorial001.py
deleted file mode 100644
index 7dcd960..0000000
--- a/tests/test_tutorial/test_metadata/test_tutorial001.py
+++ /dev/null
@@ -1,50 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.metadata.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {
-        "title": "ChimichangApp",
-        "description": "\nChimichangApp API helps you do awesome stuff. 🚀\n\n## Items\n\nYou can **read items**.\n\n## Users\n\nYou will be able to:\n\n* **Create users** (_not implemented_).\n* **Read users** (_not implemented_).\n",
-        "termsOfService": "http://example.com/terms/",
-        "contact": {
-            "name": "Deadpoolio the Amazing",
-            "url": "http://x-force.example.com/contact/",
-            "email": "dp@x-force.example.com",
-        },
-        "license": {
-            "name": "Apache 2.0",
-            "url": "https://www.apache.org/licenses/LICENSE-2.0.html",
-        },
-        "version": "0.0.1",
-    },
-    "paths": {
-        "/items/": {
-            "get": {
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_items():
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    assert response.json() == [{"name": "Katana"}]
diff --git a/tests/test_tutorial/test_metadata/test_tutorial004.py b/tests/test_tutorial/test_metadata/test_tutorial004.py
deleted file mode 100644
index 4fca3b1..0000000
--- a/tests/test_tutorial/test_metadata/test_tutorial004.py
+++ /dev/null
@@ -1,65 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.metadata.tutorial004 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/users/": {
-            "get": {
-                "tags": ["users"],
-                "summary": "Get Users",
-                "operationId": "get_users_users__get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-            }
-        },
-        "/items/": {
-            "get": {
-                "tags": ["items"],
-                "summary": "Get Items",
-                "operationId": "get_items_items__get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-            }
-        },
-    },
-    "tags": [
-        {
-            "name": "users",
-            "description": "Operations with users. The **login** logic is also here.",
-        },
-        {
-            "name": "items",
-            "description": "Manage items. So _fancy_ they have their own docs.",
-            "externalDocs": {
-                "description": "Items external docs",
-                "url": "https://squall.mtag.dev/",
-            },
-        },
-    ],
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_path_operations():
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    response = client.get("/users/")
-    assert response.status_code == 200, response.text
diff --git a/tests/test_tutorial/test_path_operation_advanced_configurations/__init__.py b/tests/test_tutorial/test_path_operation_advanced_configurations/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial001.py b/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial001.py
deleted file mode 100644
index 404960c..0000000
--- a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial001.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.path_operation_advanced_configuration.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "summary": "Read Items",
-                "operationId": "some_specific_id_you_define",
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get():
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    assert response.json() == [{"item_id": "Foo"}]
diff --git a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial002.py b/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial002.py
deleted file mode 100644
index b17a3c1..0000000
--- a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial002.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.path_operation_advanced_configuration.tutorial002 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "summary": "Read Items",
-                "operationId": "read_items",
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get():
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    assert response.json() == [{"item_id": "Foo"}]
diff --git a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial003.py b/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial003.py
deleted file mode 100644
index 26249e1..0000000
--- a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial003.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.path_operation_advanced_configuration.tutorial003 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {},
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get():
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    assert response.json() == [{"item_id": "Foo"}]
diff --git a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial004.py b/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial004.py
deleted file mode 100644
index b456ffe..0000000
--- a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial004.py
+++ /dev/null
@@ -1,111 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.path_operation_advanced_configuration.tutorial004 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Item"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create an item",
-                "description": "Create an item with all the information:\n\n- **name**: each item must have a name\n- **description**: a long description\n- **price**: required\n- **tax**: if the item doesn't have tax, you can omit this\n- **tags**: a set of unique tag strings for this item\n",
-                "operationId": "create_item_items__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/Item"}
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "required": ["name", "price"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "price": {"title": "Price", "type": "number"},
-                    "description": {"title": "Description", "type": "string"},
-                    "tax": {"title": "Tax", "type": "number"},
-                    "tags": {
-                        "title": "Tags",
-                        "uniqueItems": True,
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_query_params_str_validations():
-    response = client.post("/items/", json={"name": "Foo", "price": 42})
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "name": "Foo",
-        "price": 42,
-        "description": None,
-        "tax": None,
-        "tags": [],
-    }
diff --git a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial005.py b/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial005.py
deleted file mode 100644
index efe3ab9..0000000
--- a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial005.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.path_operation_advanced_configuration.tutorial005 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "x-aperture-labs-portal": "blue",
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_get():
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
diff --git a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial006.py b/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial006.py
deleted file mode 100644
index 5d8003e..0000000
--- a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial006.py
+++ /dev/null
@@ -1,59 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.path_operation_advanced_configuration.tutorial006 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "post": {
-                "summary": "Create Item",
-                "operationId": "create_item_items__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {
-                                "required": ["name", "price"],
-                                "type": "object",
-                                "properties": {
-                                    "name": {"type": "string"},
-                                    "price": {"type": "number"},
-                                    "description": {"type": "string"},
-                                },
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_post():
-    response = client.post("/items/", data=b"this is actually not validated")
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "size": 30,
-        "content": {
-            "name": "Maaaagic",
-            "price": 42,
-            "description": "Just kiddin', no magic here. ✨",
-        },
-    }
diff --git a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial007.py b/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial007.py
deleted file mode 100644
index 3869cde..0000000
--- a/tests/test_tutorial/test_path_operation_advanced_configurations/test_tutorial007.py
+++ /dev/null
@@ -1,97 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.path_operation_advanced_configuration.tutorial007 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "post": {
-                "summary": "Create Item",
-                "operationId": "create_item_items__post",
-                "requestBody": {
-                    "content": {
-                        "application/x-yaml": {
-                            "schema": {
-                                "title": "Item",
-                                "required": ["name", "tags"],
-                                "type": "object",
-                                "properties": {
-                                    "name": {"title": "Name", "type": "string"},
-                                    "tags": {
-                                        "title": "Tags",
-                                        "type": "array",
-                                        "items": {"type": "string"},
-                                    },
-                                },
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_post():
-    yaml_data = """
-        name: Deadpoolio
-        tags:
-        - x-force
-        - x-men
-        - x-avengers
-        """
-    response = client.post("/items/", data=yaml_data)
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "name": "Deadpoolio",
-        "tags": ["x-force", "x-men", "x-avengers"],
-    }
-
-
-def test_post_broken_yaml():
-    yaml_data = """
-        name: Deadpoolio
-        tags:
-        x - x-force
-        x - x-men
-        x - x-avengers
-        """
-    response = client.post("/items/", data=yaml_data)
-    assert response.status_code == 422, response.text
-    assert response.json() == {"detail": "Invalid YAML"}
-
-
-def test_post_invalid():
-    yaml_data = """
-        name: Deadpoolio
-        tags:
-        - x-force
-        - x-men
-        - x-avengers
-        - sneaky: object
-        """
-    response = client.post("/items/", data=yaml_data)
-    assert response.status_code == 422, response.text
-    assert response.json() == {
-        "detail": [
-            {"loc": ["tags", 3], "msg": "str type expected", "type": "type_error.str"}
-        ]
-    }
diff --git a/tests/test_tutorial/test_path_operation_configurations/__init__.py b/tests/test_tutorial/test_path_operation_configurations/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_path_operation_configurations/test_tutorial005.py b/tests/test_tutorial/test_path_operation_configurations/test_tutorial005.py
deleted file mode 100644
index d6dfdfb..0000000
--- a/tests/test_tutorial/test_path_operation_configurations/test_tutorial005.py
+++ /dev/null
@@ -1,111 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.path_operation_configuration.tutorial005 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "The created item",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Item"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create an item",
-                "description": "Create an item with all the information:\n\n- **name**: each item must have a name\n- **description**: a long description\n- **price**: required\n- **tax**: if the item doesn't have tax, you can omit this\n- **tags**: a set of unique tag strings for this item",
-                "operationId": "create_item_items__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/Item"}
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "required": ["name", "price"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "price": {"title": "Price", "type": "number"},
-                    "description": {"title": "Description", "type": "string"},
-                    "tax": {"title": "Tax", "type": "number"},
-                    "tags": {
-                        "title": "Tags",
-                        "uniqueItems": True,
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_query_params_str_validations():
-    response = client.post("/items/", json={"name": "Foo", "price": 42})
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "name": "Foo",
-        "price": 42,
-        "description": None,
-        "tax": None,
-        "tags": [],
-    }
diff --git a/tests/test_tutorial/test_path_operation_configurations/test_tutorial006.py b/tests/test_tutorial/test_path_operation_configurations/test_tutorial006.py
deleted file mode 100644
index d25a40f..0000000
--- a/tests/test_tutorial/test_path_operation_configurations/test_tutorial006.py
+++ /dev/null
@@ -1,73 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.path_operation_configuration.tutorial006 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "tags": ["items"],
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-            }
-        },
-        "/users/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "tags": ["users"],
-                "summary": "Read Users",
-                "operationId": "read_users_users__get",
-            }
-        },
-        "/elements/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "tags": ["items"],
-                "summary": "Read Elements",
-                "operationId": "read_elements_elements__get",
-                "deprecated": True,
-            }
-        },
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-@pytest.mark.parametrize(
-    "path,expected_status,expected_response",
-    [
-        ("/items/", 200, [{"name": "Foo", "price": 42}]),
-        ("/users/", 200, [{"username": "johndoe"}]),
-        ("/elements/", 200, [{"item_id": "Foo"}]),
-    ],
-)
-def test_query_params_str_validations(path, expected_status, expected_response):
-    response = client.get(path)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_path_params/__init__.py b/tests/test_tutorial/test_path_params/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_path_params/test_tutorial004.py b/tests/test_tutorial/test_path_params/test_tutorial004.py
deleted file mode 100644
index c9f22cc..0000000
--- a/tests/test_tutorial/test_path_params/test_tutorial004.py
+++ /dev/null
@@ -1,95 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.path_params.tutorial004 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/files/{file_path}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read File",
-                "operationId": "read_file_files__file_path__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "File Path", "type": "string"},
-                        "name": "file_path",
-                        "in": "path",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-@pytest.mark.skip(reason="SQUALL-19")
-def test_openapi():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-@pytest.mark.skip(reason="SQUALL-19")
-def test_file_path():
-    response = client.get("/files/home/johndoe/myfile.txt")
-    print(response.content)
-    assert response.status_code == 200, response.text
-    assert response.json() == {"file_path": "home/johndoe/myfile.txt"}
-
-
-@pytest.mark.skip(reason="SQUALL-19")
-def test_root_file_path():
-    response = client.get("/files//home/johndoe/myfile.txt")
-    print(response.content)
-    assert response.status_code == 200, response.text
-    assert response.json() == {"file_path": "/home/johndoe/myfile.txt"}
diff --git a/tests/test_tutorial/test_path_params/test_tutorial005.py b/tests/test_tutorial/test_path_params/test_tutorial005.py
deleted file mode 100644
index 97c09d4..0000000
--- a/tests/test_tutorial/test_path_params/test_tutorial005.py
+++ /dev/null
@@ -1,198 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.path_params.tutorial005 import app
-
-# client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/models/{model_name}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Get Model",
-                "operationId": "get_model_models__model_name__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {
-                            "title": "Model Name",
-                            "enum": ["alexnet", "resnet", "lenet"],
-                            "type": "string",
-                        },
-                        "name": "model_name",
-                        "in": "path",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-openapi_schema2 = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/models/{model_name}": {
-            "get": {
-                "summary": "Get Model",
-                "operationId": "get_model_models__model_name__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"$ref": "#/components/schemas/ModelName"},
-                        "name": "model_name",
-                        "in": "path",
-                    }
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-            "ModelName": {
-                "title": "ModelName",
-                "enum": ["alexnet", "resnet", "lenet"],
-                "type": "string",
-                "description": "An enumeration.",
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi():
-    with TestClient(app) as client:
-        response = client.get("/openapi.json")
-        assert response.status_code == 200, response.text
-        data = response.json()
-        assert data == openapi_schema or data == openapi_schema2
-
-
-@pytest.mark.parametrize(
-    "url,status_code,expected",
-    [
-        (
-            "/models/alexnet",
-            200,
-            {"model_name": "alexnet", "message": "Deep Learning FTW!"},
-        ),
-        (
-            "/models/lenet",
-            200,
-            {"model_name": "lenet", "message": "LeCNN all the images"},
-        ),
-        (
-            "/models/resnet",
-            200,
-            {"model_name": "resnet", "message": "Have some residuals"},
-        ),
-        (
-            "/models/foo",
-            422,
-            {
-                "detail": [
-                    {
-                        "ctx": {"enum_values": ["alexnet", "resnet", "lenet"]},
-                        "loc": ["path", "model_name"],
-                        "msg": "value is not a valid enumeration member; permitted: 'alexnet', 'resnet', 'lenet'",
-                        "type": "type_error.enum",
-                    }
-                ]
-            },
-        ),
-    ],
-)
-def test_get_enums(url, status_code, expected):
-    with TestClient(app) as client:
-        response = client.get(url)
-        assert response.status_code == status_code
-        assert response.json() == expected
diff --git a/tests/test_tutorial/test_query_params/__init__.py b/tests/test_tutorial/test_query_params/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_query_params/test_tutorial005.py b/tests/test_tutorial/test_query_params/test_tutorial005.py
deleted file mode 100644
index d01540e..0000000
--- a/tests/test_tutorial/test_query_params/test_tutorial005.py
+++ /dev/null
@@ -1,104 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.query_params.tutorial005 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read User Item",
-                "operationId": "read_user_item_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    },
-                    {
-                        "required": True,
-                        "schema": {"title": "Needy", "type": "string"},
-                        "name": "needy",
-                        "in": "query",
-                    },
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-query_required = {
-    "detail": [
-        {
-            "loc": ["query", "needy"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        }
-    ]
-}
-
-
-@pytest.mark.parametrize(
-    "path,expected_status,expected_response",
-    [
-        ("/openapi.json", 200, openapi_schema),
-        ("/items/foo?needy=very", 200, {"item_id": "foo", "needy": "very"}),
-        ("/items/foo", 422, query_required),
-        ("/items/foo", 422, query_required),
-    ],
-)
-def test(path, expected_status, expected_response):
-    response = client.get(path)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_query_params/test_tutorial006.py b/tests/test_tutorial/test_query_params/test_tutorial006.py
deleted file mode 100644
index 634ac2c..0000000
--- a/tests/test_tutorial/test_query_params/test_tutorial006.py
+++ /dev/null
@@ -1,141 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.query_params.tutorial006 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read User Item",
-                "operationId": "read_user_item_items__item_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "string"},
-                        "name": "item_id",
-                        "in": "path",
-                    },
-                    {
-                        "required": True,
-                        "schema": {"title": "Needy", "type": "string"},
-                        "name": "needy",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Skip", "type": "integer", "default": 0},
-                        "name": "skip",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Limit", "type": "integer"},
-                        "name": "limit",
-                        "in": "query",
-                    },
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-query_required = {
-    "detail": [
-        {
-            "loc": ["query", "needy"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        }
-    ]
-}
-
-
-@pytest.mark.parametrize(
-    "path,expected_status,expected_response",
-    [
-        ("/openapi.json", 200, openapi_schema),
-        (
-            "/items/foo?needy=very",
-            200,
-            {"item_id": "foo", "needy": "very", "skip": 0, "limit": None},
-        ),
-        (
-            "/items/foo?skip=a&limit=b",
-            422,
-            {
-                "detail": [
-                    {
-                        "loc": ["query", "needy"],
-                        "msg": "field required",
-                        "type": "value_error.missing",
-                    },
-                    {
-                        "loc": ["query", "skip"],
-                        "msg": "value is not a valid integer",
-                        "type": "type_error.integer",
-                    },
-                    {
-                        "loc": ["query", "limit"],
-                        "msg": "value is not a valid integer",
-                        "type": "type_error.integer",
-                    },
-                ]
-            },
-        ),
-    ],
-)
-def test(path, expected_status, expected_response):
-    response = client.get(path)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_query_params_str_validations/__init__.py b/tests/test_tutorial/test_query_params_str_validations/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_query_params_str_validations/test_tutorial001.py b/tests/test_tutorial/test_query_params_str_validations/test_tutorial001.py
deleted file mode 100644
index 87f61b9..0000000
--- a/tests/test_tutorial/test_query_params_str_validations/test_tutorial001.py
+++ /dev/null
@@ -1,122 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.query_params_str_validations.tutorial010 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "description": "Query string for the items to search in the database that have a good match",
-                        "required": False,
-                        "deprecated": True,
-                        "schema": {
-                            "title": "Query string",
-                            "maxLength": 50,
-                            "minLength": 3,
-                            "pattern": "^fixedquery$",
-                            "type": "string",
-                            "description": "Query string for the items to search in the database that have a good match",
-                        },
-                        "name": "item-query",
-                        "in": "query",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-regex_error = {
-    "detail": [
-        {
-            "ctx": {"pattern": "^fixedquery$"},
-            "loc": ["query", "item-query"],
-            "msg": 'string does not match regex "^fixedquery$"',
-            "type": "value_error.str.regex",
-        }
-    ]
-}
-
-
-@pytest.mark.parametrize(
-    "q_name,q,expected_status,expected_response",
-    [
-        (None, None, 200, {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}),
-        (
-            "item-query",
-            "fixedquery",
-            200,
-            {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}], "q": "fixedquery"},
-        ),
-        ("q", "fixedquery", 200, {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}),
-        ("item-query", "nonregexquery", 422, regex_error),
-    ],
-)
-def test_query_params_str_validations(q_name, q, expected_status, expected_response):
-    url = "/items/"
-    if q_name and q:
-        url = f"{url}?{q_name}={q}"
-    response = client.get(url)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
diff --git a/tests/test_tutorial/test_query_params_str_validations/test_tutorial011.py b/tests/test_tutorial/test_query_params_str_validations/test_tutorial011.py
deleted file mode 100644
index bd51938..0000000
--- a/tests/test_tutorial/test_query_params_str_validations/test_tutorial011.py
+++ /dev/null
@@ -1,95 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.query_params_str_validations.tutorial011 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {
-                            "title": "Q",
-                            "type": "array",
-                            "items": {"type": "string"},
-                        },
-                        "name": "q",
-                        "in": "query",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_multi_query_values():
-    url = "/items/?q=foo&q=bar"
-    response = client.get(url)
-    assert response.status_code == 200, response.text
-    assert response.json() == {"q": ["foo", "bar"]}
-
-
-def test_query_no_values():
-    url = "/items/"
-    response = client.get(url)
-    assert response.status_code == 200, response.text
-    assert response.json() == {"q": None}
diff --git a/tests/test_tutorial/test_query_params_str_validations/test_tutorial012.py b/tests/test_tutorial/test_query_params_str_validations/test_tutorial012.py
deleted file mode 100644
index 55b260a..0000000
--- a/tests/test_tutorial/test_query_params_str_validations/test_tutorial012.py
+++ /dev/null
@@ -1,96 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.query_params_str_validations.tutorial012 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {
-                            "title": "Q",
-                            "type": "array",
-                            "items": {"type": "string"},
-                            "default": ["foo", "bar"],
-                        },
-                        "name": "q",
-                        "in": "query",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_default_query_values():
-    url = "/items/"
-    response = client.get(url)
-    assert response.status_code == 200, response.text
-    assert response.json() == {"q": ["foo", "bar"]}
-
-
-def test_multi_query_values():
-    url = "/items/?q=baz&q=foobar"
-    response = client.get(url)
-    assert response.status_code == 200, response.text
-    assert response.json() == {"q": ["baz", "foobar"]}
diff --git a/tests/test_tutorial/test_query_params_str_validations/test_tutorial013.py b/tests/test_tutorial/test_query_params_str_validations/test_tutorial013.py
deleted file mode 100644
index e372149..0000000
--- a/tests/test_tutorial/test_query_params_str_validations/test_tutorial013.py
+++ /dev/null
@@ -1,96 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.query_params_str_validations.tutorial013 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {
-                            "title": "Q",
-                            "type": "array",
-                            "items": {},
-                            "default": [],
-                        },
-                        "name": "q",
-                        "in": "query",
-                    }
-                ],
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_multi_query_values():
-    url = "/items/?q=foo&q=bar"
-    response = client.get(url)
-    assert response.status_code == 200, response.text
-    assert response.json() == {"q": ["foo", "bar"]}
-
-
-def test_query_no_values():
-    url = "/items/"
-    response = client.get(url)
-    assert response.status_code == 200, response.text
-    assert response.json() == {"q": []}
diff --git a/tests/test_tutorial/test_request_files/__init__.py b/tests/test_tutorial/test_request_files/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_request_files/test_tutorial001.py b/tests/test_tutorial/test_request_files/test_tutorial001.py
deleted file mode 100644
index 8765839..0000000
--- a/tests/test_tutorial/test_request_files/test_tutorial001.py
+++ /dev/null
@@ -1,184 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.request_files.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/files/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create File",
-                "operationId": "create_file_files__post",
-                "requestBody": {
-                    "content": {
-                        "multipart/form-data": {
-                            "schema": {
-                                "$ref": "#/components/schemas/Body_create_file_files__post"
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        },
-        "/uploadfile/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create Upload File",
-                "operationId": "create_upload_file_uploadfile__post",
-                "requestBody": {
-                    "content": {
-                        "multipart/form-data": {
-                            "schema": {
-                                "$ref": "#/components/schemas/Body_create_upload_file_uploadfile__post"
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        },
-    },
-    "components": {
-        "schemas": {
-            "Body_create_upload_file_uploadfile__post": {
-                "title": "Body_create_upload_file_uploadfile__post",
-                "required": ["file"],
-                "type": "object",
-                "properties": {
-                    "file": {"title": "File", "type": "string", "format": "binary"}
-                },
-            },
-            "Body_create_file_files__post": {
-                "title": "Body_create_file_files__post",
-                "required": ["file"],
-                "type": "object",
-                "properties": {
-                    "file": {"title": "File", "type": "string", "format": "binary"}
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-file_required = {
-    "detail": [
-        {
-            "loc": ["body", "file"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        }
-    ]
-}
-
-
-def test_post_form_no_body():
-    response = client.post("/files/")
-    assert response.status_code == 422, response.text
-    assert response.json() == file_required
-
-
-def test_post_body_json():
-    response = client.post("/files/", json={"file": "Foo"})
-    assert response.status_code == 422, response.text
-    assert response.json() == file_required
-
-
-def test_post_file(tmp_path):
-    path = tmp_path / "test.txt"
-    path.write_bytes(b"<file content>")
-
-    client = TestClient(app)
-    with path.open("rb") as file:
-        response = client.post("/files/", files={"file": file})
-    assert response.status_code == 200, response.text
-    assert response.json() == {"file_size": 14}
-
-
-def test_post_large_file(tmp_path):
-    default_pydantic_max_size = 2 ** 16
-    path = tmp_path / "test.txt"
-    path.write_bytes(b"x" * (default_pydantic_max_size + 1))
-
-    client = TestClient(app)
-    with path.open("rb") as file:
-        response = client.post("/files/", files={"file": file})
-    assert response.status_code == 200, response.text
-    assert response.json() == {"file_size": default_pydantic_max_size + 1}
-
-
-def test_post_upload_file(tmp_path):
-    path = tmp_path / "test.txt"
-    path.write_bytes(b"<file content>")
-
-    client = TestClient(app)
-    with path.open("rb") as file:
-        response = client.post("/uploadfile/", files={"file": file})
-    assert response.status_code == 200, response.text
-    assert response.json() == {"filename": "test.txt"}
diff --git a/tests/test_tutorial/test_request_files/test_tutorial002.py b/tests/test_tutorial/test_request_files/test_tutorial002.py
deleted file mode 100644
index 64e273f..0000000
--- a/tests/test_tutorial/test_request_files/test_tutorial002.py
+++ /dev/null
@@ -1,215 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.request_files.tutorial002 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/files/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create Files",
-                "operationId": "create_files_files__post",
-                "requestBody": {
-                    "content": {
-                        "multipart/form-data": {
-                            "schema": {
-                                "$ref": "#/components/schemas/Body_create_files_files__post"
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        },
-        "/uploadfiles/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create Upload Files",
-                "operationId": "create_upload_files_uploadfiles__post",
-                "requestBody": {
-                    "content": {
-                        "multipart/form-data": {
-                            "schema": {
-                                "$ref": "#/components/schemas/Body_create_upload_files_uploadfiles__post"
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        },
-        "/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "summary": "Main",
-                "operationId": "main__get",
-            }
-        },
-    },
-    "components": {
-        "schemas": {
-            "Body_create_upload_files_uploadfiles__post": {
-                "title": "Body_create_upload_files_uploadfiles__post",
-                "required": ["files"],
-                "type": "object",
-                "properties": {
-                    "files": {
-                        "title": "Files",
-                        "type": "array",
-                        "items": {"type": "string", "format": "binary"},
-                    }
-                },
-            },
-            "Body_create_files_files__post": {
-                "title": "Body_create_files_files__post",
-                "required": ["files"],
-                "type": "object",
-                "properties": {
-                    "files": {
-                        "title": "Files",
-                        "type": "array",
-                        "items": {"type": "string", "format": "binary"},
-                    }
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-file_required = {
-    "detail": [
-        {
-            "loc": ["body", "files"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        }
-    ]
-}
-
-
-def test_post_form_no_body():
-    response = client.post("/files/")
-    assert response.status_code == 422, response.text
-    assert response.json() == file_required
-
-
-def test_post_body_json():
-    response = client.post("/files/", json={"file": "Foo"})
-    assert response.status_code == 422, response.text
-    assert response.json() == file_required
-
-
-def test_post_files(tmp_path):
-    path = tmp_path / "test.txt"
-    path.write_bytes(b"<file content>")
-    path2 = tmp_path / "test2.txt"
-    path2.write_bytes(b"<file content2>")
-
-    client = TestClient(app)
-    with path.open("rb") as file, path2.open("rb") as file2:
-        response = client.post(
-            "/files/",
-            files=(
-                ("files", ("test.txt", file)),
-                ("files", ("test2.txt", file2)),
-            ),
-        )
-    assert response.status_code == 200, response.text
-    assert response.json() == {"file_sizes": [14, 15]}
-
-
-def test_post_upload_file(tmp_path):
-    path = tmp_path / "test.txt"
-    path.write_bytes(b"<file content>")
-    path2 = tmp_path / "test2.txt"
-    path2.write_bytes(b"<file content2>")
-
-    client = TestClient(app)
-    with path.open("rb") as file, path2.open("rb") as file2:
-        response = client.post(
-            "/uploadfiles/",
-            files=(
-                ("files", ("test.txt", file)),
-                ("files", ("test2.txt", file2)),
-            ),
-        )
-    assert response.status_code == 200, response.text
-    assert response.json() == {"filenames": ["test.txt", "test2.txt"]}
-
-
-def test_get_root():
-    client = TestClient(app)
-    response = client.get("/")
-    assert response.status_code == 200, response.text
-    assert b"<form" in response.content
diff --git a/tests/test_tutorial/test_request_forms/__init__.py b/tests/test_tutorial/test_request_forms/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_request_forms/test_tutorial001.py b/tests/test_tutorial/test_request_forms/test_tutorial001.py
deleted file mode 100644
index 16a9626..0000000
--- a/tests/test_tutorial/test_request_forms/test_tutorial001.py
+++ /dev/null
@@ -1,149 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-
-from docs_src.request_forms.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/login/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Login",
-                "operationId": "login_login__post",
-                "requestBody": {
-                    "content": {
-                        "application/x-www-form-urlencoded": {
-                            "schema": {
-                                "$ref": "#/components/schemas/Body_login_login__post"
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Body_login_login__post": {
-                "title": "Body_login_login__post",
-                "required": ["username", "password"],
-                "type": "object",
-                "properties": {
-                    "username": {"title": "Username", "type": "string"},
-                    "password": {"title": "Password", "type": "string"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-password_required = {
-    "detail": [
-        {
-            "loc": ["body", "password"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        }
-    ]
-}
-username_required = {
-    "detail": [
-        {
-            "loc": ["body", "username"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        }
-    ]
-}
-username_and_password_required = {
-    "detail": [
-        {
-            "loc": ["body", "username"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        },
-        {
-            "loc": ["body", "password"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        },
-    ]
-}
-
-
-@pytest.mark.parametrize(
-    "path,body,expected_status,expected_response",
-    [
-        (
-            "/login/",
-            {"username": "Foo", "password": "secret"},
-            200,
-            {"username": "Foo"},
-        ),
-        ("/login/", {"username": "Foo"}, 422, password_required),
-        ("/login/", {"password": "secret"}, 422, username_required),
-        ("/login/", None, 422, username_and_password_required),
-    ],
-)
-def test_post_body_form(path, body, expected_status, expected_response):
-    response = client.post(path, data=body)
-    assert response.status_code == expected_status
-    assert response.json() == expected_response
-
-
-def test_post_body_json():
-    response = client.post("/login/", json={"username": "Foo", "password": "secret"})
-    assert response.status_code == 422, response.text
-    assert response.json() == username_and_password_required
diff --git a/tests/test_tutorial/test_request_forms_and_files/__init__.py b/tests/test_tutorial/test_request_forms_and_files/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_request_forms_and_files/test_tutorial001.py b/tests/test_tutorial/test_request_forms_and_files/test_tutorial001.py
deleted file mode 100644
index 4be28e9..0000000
--- a/tests/test_tutorial/test_request_forms_and_files/test_tutorial001.py
+++ /dev/null
@@ -1,192 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.request_forms_and_files.tutorial001 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/files/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create File",
-                "operationId": "create_file_files__post",
-                "requestBody": {
-                    "content": {
-                        "multipart/form-data": {
-                            "schema": {
-                                "$ref": "#/components/schemas/Body_create_file_files__post"
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Body_create_file_files__post": {
-                "title": "Body_create_file_files__post",
-                "required": ["file", "fileb", "token"],
-                "type": "object",
-                "properties": {
-                    "file": {"title": "File", "type": "string", "format": "binary"},
-                    "fileb": {"title": "Fileb", "type": "string", "format": "binary"},
-                    "token": {"title": "Token", "type": "string"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-file_required = {
-    "detail": [
-        {
-            "loc": ["body", "file"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        },
-        {
-            "loc": ["body", "fileb"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        },
-    ]
-}
-
-token_required = {
-    "detail": [
-        {
-            "loc": ["body", "fileb"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        },
-        {
-            "loc": ["body", "token"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        },
-    ]
-}
-
-# {'detail': [, {'loc': ['body', 'token'], 'msg': 'field required', 'type': 'value_error.missing'}]}
-
-file_and_token_required = {
-    "detail": [
-        {
-            "loc": ["body", "file"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        },
-        {
-            "loc": ["body", "fileb"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        },
-        {
-            "loc": ["body", "token"],
-            "msg": "field required",
-            "type": "value_error.missing",
-        },
-    ]
-}
-
-
-def test_post_form_no_body():
-    response = client.post("/files/")
-    assert response.status_code == 422, response.text
-    assert response.json() == file_and_token_required
-
-
-def test_post_form_no_file():
-    response = client.post("/files/", data={"token": "foo"})
-    assert response.status_code == 422, response.text
-    assert response.json() == file_required
-
-
-def test_post_body_json():
-    response = client.post("/files/", json={"file": "Foo", "token": "Bar"})
-    assert response.status_code == 422, response.text
-    assert response.json() == file_and_token_required
-
-
-def test_post_file_no_token(tmp_path):
-    path = tmp_path / "test.txt"
-    path.write_bytes(b"<file content>")
-
-    client = TestClient(app)
-    with path.open("rb") as file:
-        response = client.post("/files/", files={"file": file})
-    assert response.status_code == 422, response.text
-    assert response.json() == token_required
-
-
-def test_post_files_and_token(tmp_path):
-    patha = tmp_path / "test.txt"
-    pathb = tmp_path / "testb.txt"
-    patha.write_text("<file content>")
-    pathb.write_text("<file b content>")
-
-    client = TestClient(app)
-    with patha.open("rb") as filea, pathb.open("rb") as fileb:
-        response = client.post(
-            "/files/",
-            data={"token": "foo"},
-            files={"file": filea, "fileb": ("testb.txt", fileb, "text/plain")},
-        )
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "file_size": 14,
-        "token": "foo",
-        "fileb_content_type": "text/plain",
-    }
diff --git a/tests/test_tutorial/test_response_change_status_code/__init__.py b/tests/test_tutorial/test_response_change_status_code/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_response_change_status_code/test_tutorial001.py b/tests/test_tutorial/test_response_change_status_code/test_tutorial001.py
deleted file mode 100644
index 1ef872b..0000000
--- a/tests/test_tutorial/test_response_change_status_code/test_tutorial001.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.response_change_status_code.tutorial001 import app
-
-client = TestClient(app)
-
-
-def test_path_operation():
-    response = client.put("/get-or-create-task/foo")
-    print(response.content)
-    assert response.status_code == 200, response.text
-    assert response.json() == "Listen to the Bar Fighters"
-    response = client.put("/get-or-create-task/bar")
-    assert response.status_code == 201, response.text
-    assert response.json() == "This didn't exist before"
diff --git a/tests/test_tutorial/test_response_cookies/__init__.py b/tests/test_tutorial/test_response_cookies/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_response_cookies/test_tutorial001.py b/tests/test_tutorial/test_response_cookies/test_tutorial001.py
deleted file mode 100644
index cfe84e1..0000000
--- a/tests/test_tutorial/test_response_cookies/test_tutorial001.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.response_cookies.tutorial001 import app
-
-client = TestClient(app)
-
-
-def test_path_operation():
-    response = client.post("/cookie/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"message": "Come to the dark side, we have cookies"}
-    assert response.cookies["fakesession"] == "fake-cookie-session-value"
diff --git a/tests/test_tutorial/test_response_cookies/test_tutorial002.py b/tests/test_tutorial/test_response_cookies/test_tutorial002.py
deleted file mode 100644
index e828699..0000000
--- a/tests/test_tutorial/test_response_cookies/test_tutorial002.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.response_cookies.tutorial002 import app
-
-client = TestClient(app)
-
-
-def test_path_operation():
-    response = client.post("/cookie-and-object/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"message": "Come to the dark side, we have cookies"}
-    assert response.cookies["fakesession"] == "fake-cookie-session-value"
diff --git a/tests/test_tutorial/test_response_headers/__init__.py b/tests/test_tutorial/test_response_headers/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_response_headers/test_tutorial001.py b/tests/test_tutorial/test_response_headers/test_tutorial001.py
deleted file mode 100644
index cf1cdb5..0000000
--- a/tests/test_tutorial/test_response_headers/test_tutorial001.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.response_headers.tutorial001 import app
-
-client = TestClient(app)
-
-
-def test_path_operation():
-    response = client.get("/headers/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"message": "Hello World"}
-    assert response.headers["X-Cat-Dog"] == "alone in the world"
-    assert response.headers["Content-Language"] == "en-US"
diff --git a/tests/test_tutorial/test_response_headers/test_tutorial002.py b/tests/test_tutorial/test_response_headers/test_tutorial002.py
deleted file mode 100644
index 99caf63..0000000
--- a/tests/test_tutorial/test_response_headers/test_tutorial002.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.response_headers.tutorial002 import app
-
-client = TestClient(app)
-
-
-def test_path_operation():
-    response = client.get("/headers-and-object/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {"message": "Hello World"}
-    assert response.headers["X-Cat-Dog"] == "alone in the world"
diff --git a/tests/test_tutorial/test_response_model/__init__.py b/tests/test_tutorial/test_response_model/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_response_model/test_tutorial003.py b/tests/test_tutorial/test_response_model/test_tutorial003.py
deleted file mode 100644
index 32d0c82..0000000
--- a/tests/test_tutorial/test_response_model/test_tutorial003.py
+++ /dev/null
@@ -1,120 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.response_model.tutorial003 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/user/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/UserOut"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create User",
-                "operationId": "create_user_user__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/UserIn"}
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "UserOut": {
-                "title": "UserOut",
-                "required": ["username", "email"],
-                "type": "object",
-                "properties": {
-                    "username": {"title": "Username", "type": "string"},
-                    "email": {"title": "Email", "type": "string", "format": "email"},
-                    "full_name": {"title": "Full Name", "type": "string"},
-                },
-            },
-            "UserIn": {
-                "title": "UserIn",
-                "required": ["username", "password", "email"],
-                "type": "object",
-                "properties": {
-                    "username": {"title": "Username", "type": "string"},
-                    "password": {"title": "Password", "type": "string"},
-                    "email": {"title": "Email", "type": "string", "format": "email"},
-                    "full_name": {"title": "Full Name", "type": "string"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_post_user():
-    response = client.post(
-        "/user/",
-        json={
-            "username": "foo",
-            "password": "fighter",
-            "email": "foo@example.com",
-            "full_name": "Grave Dohl",
-        },
-    )
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "username": "foo",
-        "email": "foo@example.com",
-        "full_name": "Grave Dohl",
-    }
diff --git a/tests/test_tutorial/test_schema_extra_example/__init__.py b/tests/test_tutorial/test_schema_extra_example/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_schema_extra_example/test_tutorial004.py b/tests/test_tutorial/test_schema_extra_example/test_tutorial004.py
deleted file mode 100644
index 4c9c4ea..0000000
--- a/tests/test_tutorial/test_schema_extra_example/test_tutorial004.py
+++ /dev/null
@@ -1,134 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.schema_extra_example.tutorial004 import app
-
-client = TestClient(app)
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/{item_id}": {
-            "put": {
-                "summary": "Update Item",
-                "operationId": "update_item_items__item_id__put",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "Item Id", "type": "integer"},
-                        "name": "item_id",
-                        "in": "path",
-                    }
-                ],
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/Item"},
-                            "examples": {
-                                "normal": {
-                                    "summary": "A normal example",
-                                    "description": "A **normal** item works correctly.",
-                                    "value": {
-                                        "name": "Foo",
-                                        "description": "A very nice Item",
-                                        "price": 35.4,
-                                        "tax": 3.2,
-                                    },
-                                },
-                                "converted": {
-                                    "summary": "An example with converted data",
-                                    "description": "Squall can convert price `strings` to actual `numbers` automatically",
-                                    "value": {"name": "Bar", "price": "35.4"},
-                                },
-                                "invalid": {
-                                    "summary": "Invalid data is rejected with an error",
-                                    "value": {
-                                        "name": "Baz",
-                                        "price": "thirty five point four",
-                                    },
-                                },
-                            },
-                        }
-                    },
-                    "required": True,
-                },
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-            "Item": {
-                "title": "Item",
-                "required": ["name", "price"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "description": {"title": "Description", "type": "string"},
-                    "price": {"title": "Price", "type": "number"},
-                    "tax": {"title": "Tax", "type": "number"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-# Test required and embedded body parameters with no bodies sent
-def test_post_body_example():
-    response = client.put(
-        "/items/5",
-        json={
-            "name": "Foo",
-            "description": "A very nice Item",
-            "price": 35.4,
-            "tax": 3.2,
-        },
-    )
-    assert response.status_code == 200
diff --git a/tests/test_tutorial/test_settings/__init__.py b/tests/test_tutorial/test_settings/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_settings/test_app02.py b/tests/test_tutorial/test_settings/test_app02.py
deleted file mode 100644
index 0716763..0000000
--- a/tests/test_tutorial/test_settings/test_app02.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from pytest import MonkeyPatch
-from squall.testclient import TestClient
-
-from docs_src.settings.app02 import main, test_main
-
-client = TestClient(main.app)
-
-
-def test_settings(monkeypatch: MonkeyPatch):
-    monkeypatch.setenv("ADMIN_EMAIL", "admin@example.com")
-    settings = main.get_settings()
-    assert settings.app_name == "Awesome API"
-    assert settings.items_per_user == 50
-
-
-def test_override_settings():
-    test_main.test_app()
diff --git a/tests/test_tutorial/test_sql_databases/__init__.py b/tests/test_tutorial/test_sql_databases/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_sql_databases/test_sql_databases.py b/tests/test_tutorial/test_sql_databases/test_sql_databases.py
deleted file mode 100644
index 9e1fb14..0000000
--- a/tests/test_tutorial/test_sql_databases/test_sql_databases.py
+++ /dev/null
@@ -1,369 +0,0 @@
-import importlib
-from pathlib import Path
-
-import pytest
-from squall.testclient import TestClient
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/users/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "title": "Response Read Users Users  Get",
-                                    "type": "array",
-                                    "items": {"$ref": "#/components/schemas/User"},
-                                }
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Users",
-                "operationId": "read_users_users__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {"title": "Skip", "type": "integer", "default": 0},
-                        "name": "skip",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Limit", "type": "integer", "default": 100},
-                        "name": "limit",
-                        "in": "query",
-                    },
-                ],
-            },
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/User"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create User",
-                "operationId": "create_user_users__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/UserCreate"}
-                        }
-                    },
-                    "required": True,
-                },
-            },
-        },
-        "/users/{user_id}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/User"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read User",
-                "operationId": "read_user_users__user_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "User Id", "type": "integer"},
-                        "name": "user_id",
-                        "in": "path",
-                    }
-                ],
-            }
-        },
-        "/users/{user_id}/items/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Item"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create Item For User",
-                "operationId": "create_item_for_user_users__user_id__items__post",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "User Id", "type": "integer"},
-                        "name": "user_id",
-                        "in": "path",
-                    }
-                ],
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/ItemCreate"}
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        },
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "title": "Response Read Items Items  Get",
-                                    "type": "array",
-                                    "items": {"$ref": "#/components/schemas/Item"},
-                                }
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {"title": "Skip", "type": "integer", "default": 0},
-                        "name": "skip",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Limit", "type": "integer", "default": 100},
-                        "name": "limit",
-                        "in": "query",
-                    },
-                ],
-            }
-        },
-    },
-    "components": {
-        "schemas": {
-            "ItemCreate": {
-                "title": "ItemCreate",
-                "required": ["title"],
-                "type": "object",
-                "properties": {
-                    "title": {"title": "Title", "type": "string"},
-                    "description": {"title": "Description", "type": "string"},
-                },
-            },
-            "Item": {
-                "title": "Item",
-                "required": ["title", "id", "owner_id"],
-                "type": "object",
-                "properties": {
-                    "title": {"title": "Title", "type": "string"},
-                    "description": {"title": "Description", "type": "string"},
-                    "id": {"title": "Id", "type": "integer"},
-                    "owner_id": {"title": "Owner Id", "type": "integer"},
-                },
-            },
-            "User": {
-                "title": "User",
-                "required": ["email", "id", "is_active"],
-                "type": "object",
-                "properties": {
-                    "email": {"title": "Email", "type": "string"},
-                    "id": {"title": "Id", "type": "integer"},
-                    "is_active": {"title": "Is Active", "type": "boolean"},
-                    "items": {
-                        "title": "Items",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/Item"},
-                        "default": [],
-                    },
-                },
-            },
-            "UserCreate": {
-                "title": "UserCreate",
-                "required": ["email", "password"],
-                "type": "object",
-                "properties": {
-                    "email": {"title": "Email", "type": "string"},
-                    "password": {"title": "Password", "type": "string"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-@pytest.fixture(scope="module")
-def client():
-    test_db = Path("./sql_app.db")
-    if test_db.is_file():  # pragma: nocover
-        test_db.unlink()
-    # Import while creating the client to create the DB after starting the test session
-    from docs_src.sql_databases.sql_app import main
-
-    # Ensure import side effects are re-executed
-    importlib.reload(main)
-    with TestClient(main.app) as c:
-        yield c
-    if test_db.is_file():  # pragma: nocover
-        test_db.unlink()
-
-
-def test_openapi_schema(client):
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_create_user(client):
-    test_user = {"email": "johndoe@example.com", "password": "secret"}
-    response = client.post("/users/", json=test_user)
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert test_user["email"] == data["email"]
-    assert "id" in data
-    response = client.post("/users/", json=test_user)
-    assert response.status_code == 400, response.text
-
-
-def test_get_user(client):
-    response = client.get("/users/1")
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert "email" in data
-    assert "id" in data
-
-
-def test_inexistent_user(client):
-    response = client.get("/users/999")
-    assert response.status_code == 404, response.text
-
-
-def test_get_users(client):
-    response = client.get("/users/")
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert "email" in data[0]
-    assert "id" in data[0]
-
-
-def test_create_item(client):
-    item = {"title": "Foo", "description": "Something that fights"}
-    response = client.post("/users/1/items/", json=item)
-    assert response.status_code == 200, response.text
-    item_data = response.json()
-    assert item["title"] == item_data["title"]
-    assert item["description"] == item_data["description"]
-    assert "id" in item_data
-    assert "owner_id" in item_data
-    response = client.get("/users/1")
-    assert response.status_code == 200, response.text
-    user_data = response.json()
-    item_to_check = [it for it in user_data["items"] if it["id"] == item_data["id"]][0]
-    assert item_to_check["title"] == item["title"]
-    assert item_to_check["description"] == item["description"]
-    response = client.get("/users/1")
-    assert response.status_code == 200, response.text
-    user_data = response.json()
-    item_to_check = [it for it in user_data["items"] if it["id"] == item_data["id"]][0]
-    assert item_to_check["title"] == item["title"]
-    assert item_to_check["description"] == item["description"]
-
-
-def test_read_items(client):
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert data
-    first_item = data[0]
-    assert "title" in first_item
-    assert "description" in first_item
diff --git a/tests/test_tutorial/test_sql_databases/test_sql_databases_middleware.py b/tests/test_tutorial/test_sql_databases/test_sql_databases_middleware.py
deleted file mode 100644
index f05d65d..0000000
--- a/tests/test_tutorial/test_sql_databases/test_sql_databases_middleware.py
+++ /dev/null
@@ -1,370 +0,0 @@
-import importlib
-from pathlib import Path
-
-import pytest
-from squall.testclient import TestClient
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/users/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "title": "Response Read Users Users  Get",
-                                    "type": "array",
-                                    "items": {"$ref": "#/components/schemas/User"},
-                                }
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Users",
-                "operationId": "read_users_users__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {"title": "Skip", "type": "integer", "default": 0},
-                        "name": "skip",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Limit", "type": "integer", "default": 100},
-                        "name": "limit",
-                        "in": "query",
-                    },
-                ],
-            },
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/User"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create User",
-                "operationId": "create_user_users__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/UserCreate"}
-                        }
-                    },
-                    "required": True,
-                },
-            },
-        },
-        "/users/{user_id}": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/User"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read User",
-                "operationId": "read_user_users__user_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "User Id", "type": "integer"},
-                        "name": "user_id",
-                        "in": "path",
-                    }
-                ],
-            }
-        },
-        "/users/{user_id}/items/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Item"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Create Item For User",
-                "operationId": "create_item_for_user_users__user_id__items__post",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "User Id", "type": "integer"},
-                        "name": "user_id",
-                        "in": "path",
-                    }
-                ],
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/ItemCreate"}
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        },
-        "/items/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "title": "Response Read Items Items  Get",
-                                    "type": "array",
-                                    "items": {"$ref": "#/components/schemas/Item"},
-                                }
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {"title": "Skip", "type": "integer", "default": 0},
-                        "name": "skip",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Limit", "type": "integer", "default": 100},
-                        "name": "limit",
-                        "in": "query",
-                    },
-                ],
-            }
-        },
-    },
-    "components": {
-        "schemas": {
-            "ItemCreate": {
-                "title": "ItemCreate",
-                "required": ["title"],
-                "type": "object",
-                "properties": {
-                    "title": {"title": "Title", "type": "string"},
-                    "description": {"title": "Description", "type": "string"},
-                },
-            },
-            "Item": {
-                "title": "Item",
-                "required": ["title", "id", "owner_id"],
-                "type": "object",
-                "properties": {
-                    "title": {"title": "Title", "type": "string"},
-                    "description": {"title": "Description", "type": "string"},
-                    "id": {"title": "Id", "type": "integer"},
-                    "owner_id": {"title": "Owner Id", "type": "integer"},
-                },
-            },
-            "User": {
-                "title": "User",
-                "required": ["email", "id", "is_active"],
-                "type": "object",
-                "properties": {
-                    "email": {"title": "Email", "type": "string"},
-                    "id": {"title": "Id", "type": "integer"},
-                    "is_active": {"title": "Is Active", "type": "boolean"},
-                    "items": {
-                        "title": "Items",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/Item"},
-                        "default": [],
-                    },
-                },
-            },
-            "UserCreate": {
-                "title": "UserCreate",
-                "required": ["email", "password"],
-                "type": "object",
-                "properties": {
-                    "email": {"title": "Email", "type": "string"},
-                    "password": {"title": "Password", "type": "string"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-@pytest.fixture(scope="module")
-def client():
-    test_db = Path("./sql_app.db")
-    if test_db.is_file():  # pragma: nocover
-        test_db.unlink()
-    # Import while creating the client to create the DB after starting the test session
-    from docs_src.sql_databases.sql_app import alt_main
-
-    # Ensure import side effects are re-executed
-    importlib.reload(alt_main)
-
-    with TestClient(alt_main.app) as c:
-        yield c
-    if test_db.is_file():  # pragma: nocover
-        test_db.unlink()
-
-
-def test_openapi_schema(client):
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_create_user(client):
-    test_user = {"email": "johndoe@example.com", "password": "secret"}
-    response = client.post("/users/", json=test_user)
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert test_user["email"] == data["email"]
-    assert "id" in data
-    response = client.post("/users/", json=test_user)
-    assert response.status_code == 400, response.text
-
-
-def test_get_user(client):
-    response = client.get("/users/1")
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert "email" in data
-    assert "id" in data
-
-
-def test_inexistent_user(client):
-    response = client.get("/users/999")
-    assert response.status_code == 404, response.text
-
-
-def test_get_users(client):
-    response = client.get("/users/")
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert "email" in data[0]
-    assert "id" in data[0]
-
-
-def test_create_item(client):
-    item = {"title": "Foo", "description": "Something that fights"}
-    response = client.post("/users/1/items/", json=item)
-    assert response.status_code == 200, response.text
-    item_data = response.json()
-    assert item["title"] == item_data["title"]
-    assert item["description"] == item_data["description"]
-    assert "id" in item_data
-    assert "owner_id" in item_data
-    response = client.get("/users/1")
-    assert response.status_code == 200, response.text
-    user_data = response.json()
-    item_to_check = [it for it in user_data["items"] if it["id"] == item_data["id"]][0]
-    assert item_to_check["title"] == item["title"]
-    assert item_to_check["description"] == item["description"]
-    response = client.get("/users/1")
-    assert response.status_code == 200, response.text
-    user_data = response.json()
-    item_to_check = [it for it in user_data["items"] if it["id"] == item_data["id"]][0]
-    assert item_to_check["title"] == item["title"]
-    assert item_to_check["description"] == item["description"]
-
-
-def test_read_items(client):
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert data
-    first_item = data[0]
-    assert "title" in first_item
-    assert "description" in first_item
diff --git a/tests/test_tutorial/test_sql_databases/test_testing_databases.py b/tests/test_tutorial/test_sql_databases/test_testing_databases.py
deleted file mode 100644
index 9acfd89..0000000
--- a/tests/test_tutorial/test_sql_databases/test_testing_databases.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import importlib
-from pathlib import Path
-
-
-def test_testing_dbs():
-    test_db = Path("./test.db")
-    if test_db.is_file():  # pragma: nocover
-        test_db.unlink()
-    # Import while creating the client to create the DB after starting the test session
-    from docs_src.sql_databases.sql_app.tests import test_sql_app
-
-    # Ensure import side effects are re-executed
-    importlib.reload(test_sql_app)
-    test_sql_app.test_create_user()
-    if test_db.is_file():  # pragma: nocover
-        test_db.unlink()
diff --git a/tests/test_tutorial/test_sql_databases_peewee/__init__.py b/tests/test_tutorial/test_sql_databases_peewee/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_sql_databases_peewee/test_sql_databases_peewee.py b/tests/test_tutorial/test_sql_databases_peewee/test_sql_databases_peewee.py
deleted file mode 100644
index f420549..0000000
--- a/tests/test_tutorial/test_sql_databases_peewee/test_sql_databases_peewee.py
+++ /dev/null
@@ -1,430 +0,0 @@
-import time
-from pathlib import Path
-from unittest.mock import MagicMock
-
-import pytest
-from squall.testclient import TestClient
-
-from ...utils import needs_py37
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/users/": {
-            "get": {
-                "summary": "Read Users",
-                "operationId": "read_users_users__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {"title": "Skip", "type": "integer", "default": 0},
-                        "name": "skip",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Limit", "type": "integer", "default": 100},
-                        "name": "limit",
-                        "in": "query",
-                    },
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "title": "Response Read Users Users  Get",
-                                    "type": "array",
-                                    "items": {"$ref": "#/components/schemas/User"},
-                                }
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            },
-            "post": {
-                "summary": "Create User",
-                "operationId": "create_user_users__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/UserCreate"}
-                        }
-                    },
-                    "required": True,
-                },
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/User"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            },
-        },
-        "/users/{user_id}": {
-            "get": {
-                "summary": "Read User",
-                "operationId": "read_user_users__user_id__get",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "User Id", "type": "integer"},
-                        "name": "user_id",
-                        "in": "path",
-                    }
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/User"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-        "/users/{user_id}/items/": {
-            "post": {
-                "summary": "Create Item For User",
-                "operationId": "create_item_for_user_users__user_id__items__post",
-                "parameters": [
-                    {
-                        "required": True,
-                        "schema": {"title": "User Id", "type": "integer"},
-                        "name": "user_id",
-                        "in": "path",
-                    }
-                ],
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {"$ref": "#/components/schemas/ItemCreate"}
-                        }
-                    },
-                    "required": True,
-                },
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schemas/Item"}
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-        "/items/": {
-            "get": {
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {"title": "Skip", "type": "integer", "default": 0},
-                        "name": "skip",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Limit", "type": "integer", "default": 100},
-                        "name": "limit",
-                        "in": "query",
-                    },
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "title": "Response Read Items Items  Get",
-                                    "type": "array",
-                                    "items": {"$ref": "#/components/schemas/Item"},
-                                }
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-        "/slowusers/": {
-            "get": {
-                "summary": "Read Slow Users",
-                "operationId": "read_slow_users_slowusers__get",
-                "parameters": [
-                    {
-                        "required": False,
-                        "schema": {"title": "Skip", "type": "integer", "default": 0},
-                        "name": "skip",
-                        "in": "query",
-                    },
-                    {
-                        "required": False,
-                        "schema": {"title": "Limit", "type": "integer", "default": 100},
-                        "name": "limit",
-                        "in": "query",
-                    },
-                ],
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "title": "Response Read Slow Users Slowusers  Get",
-                                    "type": "array",
-                                    "items": {"$ref": "#/components/schemas/User"},
-                                }
-                            }
-                        },
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-            }
-        },
-    },
-    "components": {
-        "schemas": {
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-            "Item": {
-                "title": "Item",
-                "required": ["title", "id", "owner_id"],
-                "type": "object",
-                "properties": {
-                    "title": {"title": "Title", "type": "string"},
-                    "description": {"title": "Description", "type": "string"},
-                    "id": {"title": "Id", "type": "integer"},
-                    "owner_id": {"title": "Owner Id", "type": "integer"},
-                },
-            },
-            "ItemCreate": {
-                "title": "ItemCreate",
-                "required": ["title"],
-                "type": "object",
-                "properties": {
-                    "title": {"title": "Title", "type": "string"},
-                    "description": {"title": "Description", "type": "string"},
-                },
-            },
-            "User": {
-                "title": "User",
-                "required": ["email", "id", "is_active"],
-                "type": "object",
-                "properties": {
-                    "email": {"title": "Email", "type": "string"},
-                    "id": {"title": "Id", "type": "integer"},
-                    "is_active": {"title": "Is Active", "type": "boolean"},
-                    "items": {
-                        "title": "Items",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/Item"},
-                        "default": [],
-                    },
-                },
-            },
-            "UserCreate": {
-                "title": "UserCreate",
-                "required": ["email", "password"],
-                "type": "object",
-                "properties": {
-                    "email": {"title": "Email", "type": "string"},
-                    "password": {"title": "Password", "type": "string"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-        }
-    },
-}
-
-
-@pytest.fixture(scope="module")
-def client():
-    # Import while creating the client to create the DB after starting the test session
-    from docs_src.sql_databases_peewee.sql_app.main import app
-
-    test_db = Path("./test.db")
-    with TestClient(app) as c:
-        yield c
-    test_db.unlink()
-
-
-@needs_py37
-def test_openapi_schema(client):
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-@needs_py37
-def test_create_user(client):
-    test_user = {"email": "johndoe@example.com", "password": "secret"}
-    response = client.post("/users/", json=test_user)
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert test_user["email"] == data["email"]
-    assert "id" in data
-    response = client.post("/users/", json=test_user)
-    assert response.status_code == 400, response.text
-
-
-@needs_py37
-def test_get_user(client):
-    response = client.get("/users/1")
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert "email" in data
-    assert "id" in data
-
-
-@needs_py37
-def test_inexistent_user(client):
-    response = client.get("/users/999")
-    assert response.status_code == 404, response.text
-
-
-@needs_py37
-def test_get_users(client):
-    response = client.get("/users/")
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert "email" in data[0]
-    assert "id" in data[0]
-
-
-time.sleep = MagicMock()
-
-
-@needs_py37
-def test_get_slowusers(client):
-    response = client.get("/slowusers/")
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert "email" in data[0]
-    assert "id" in data[0]
-
-
-@needs_py37
-def test_create_item(client):
-    item = {"title": "Foo", "description": "Something that fights"}
-    response = client.post("/users/1/items/", json=item)
-    assert response.status_code == 200, response.text
-    item_data = response.json()
-    assert item["title"] == item_data["title"]
-    assert item["description"] == item_data["description"]
-    assert "id" in item_data
-    assert "owner_id" in item_data
-    response = client.get("/users/1")
-    assert response.status_code == 200, response.text
-    user_data = response.json()
-    item_to_check = [it for it in user_data["items"] if it["id"] == item_data["id"]][0]
-    assert item_to_check["title"] == item["title"]
-    assert item_to_check["description"] == item["description"]
-    response = client.get("/users/1")
-    assert response.status_code == 200, response.text
-    user_data = response.json()
-    item_to_check = [it for it in user_data["items"] if it["id"] == item_data["id"]][0]
-    assert item_to_check["title"] == item["title"]
-    assert item_to_check["description"] == item["description"]
-
-
-@needs_py37
-def test_read_items(client):
-    response = client.get("/items/")
-    assert response.status_code == 200, response.text
-    data = response.json()
-    assert data
-    first_item = data[0]
-    assert "title" in first_item
-    assert "description" in first_item
diff --git a/tests/test_tutorial/test_templates/__init__.py b/tests/test_tutorial/test_templates/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_templates/test_tutorial001.py b/tests/test_tutorial/test_templates/test_tutorial001.py
deleted file mode 100644
index 0538dd1..0000000
--- a/tests/test_tutorial/test_templates/test_tutorial001.py
+++ /dev/null
@@ -1,19 +0,0 @@
-#
-# def test_main():
-#     if os.path.isdir("./static"):  # pragma: nocover
-#         shutil.rmtree("./static")
-#     if os.path.isdir("./templates"):  # pragma: nocover
-#         shutil.rmtree("./templates")
-#     shutil.copytree("./docs_src/templates/templates/", "./templates")
-#     shutil.copytree("./docs_src/templates/static/", "./static")
-#     from docs_src.templates.tutorial001 import app
-#
-#     client = TestClient(app)
-#     response = client.get("/items/foo")
-#     assert response.status_code == 200, response.text
-#     assert b"<h1>Item ID: foo</h1>" in response.content
-#     response = client.get("/static/styles.css")
-#     assert response.status_code == 200, response.text
-#     assert b"color: green;" in response.content
-#     shutil.rmtree("./templates")
-#     shutil.rmtree("./static")
diff --git a/tests/test_tutorial/test_testing/__init__.py b/tests/test_tutorial/test_testing/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_testing/test_main.py b/tests/test_tutorial/test_testing/test_main.py
deleted file mode 100644
index b89417b..0000000
--- a/tests/test_tutorial/test_testing/test_main.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from docs_src.app_testing.test_main import client, test_read_main
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "summary": "Read Main",
-                "operationId": "read_main__get",
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_main():
-    test_read_main()
diff --git a/tests/test_tutorial/test_testing/test_main_b.py b/tests/test_tutorial/test_testing/test_main_b.py
deleted file mode 100644
index 820e485..0000000
--- a/tests/test_tutorial/test_testing/test_main_b.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from docs_src.app_testing import test_main_b
-
-
-def test_app():
-    test_main_b.test_create_existing_item()
-    test_main_b.test_create_item()
-    test_main_b.test_create_item_bad_token()
-    test_main_b.test_read_inexistent_item()
-    test_main_b.test_read_item()
-    test_main_b.test_read_item_bad_token()
diff --git a/tests/test_tutorial/test_testing/test_tutorial001.py b/tests/test_tutorial/test_testing/test_tutorial001.py
deleted file mode 100644
index c431785..0000000
--- a/tests/test_tutorial/test_testing/test_tutorial001.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from docs_src.app_testing.tutorial001 import client, test_read_main
-
-openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/": {
-            "get": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    }
-                },
-                "summary": "Read Main",
-                "operationId": "read_main__get",
-            }
-        }
-    },
-}
-
-
-def test_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == openapi_schema
-
-
-def test_main():
-    test_read_main()
diff --git a/tests/test_tutorial/test_testing/test_tutorial002.py b/tests/test_tutorial/test_testing/test_tutorial002.py
deleted file mode 100644
index ec4f91e..0000000
--- a/tests/test_tutorial/test_testing/test_tutorial002.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from docs_src.app_testing.tutorial002 import test_read_main, test_websocket
-
-
-def test_main():
-    test_read_main()
-
-
-def test_ws():
-    test_websocket()
diff --git a/tests/test_tutorial/test_testing/test_tutorial003.py b/tests/test_tutorial/test_testing/test_tutorial003.py
deleted file mode 100644
index d9e1639..0000000
--- a/tests/test_tutorial/test_testing/test_tutorial003.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from docs_src.app_testing.tutorial003 import test_read_items
-
-
-def test_main():
-    test_read_items()
diff --git a/tests/test_tutorial/test_testing_dependencies/__init__.py b/tests/test_tutorial/test_testing_dependencies/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_testing_dependencies/test_tutorial001.py b/tests/test_tutorial/test_testing_dependencies/test_tutorial001.py
deleted file mode 100644
index af26307..0000000
--- a/tests/test_tutorial/test_testing_dependencies/test_tutorial001.py
+++ /dev/null
@@ -1,56 +0,0 @@
-from docs_src.dependency_testing.tutorial001 import (
-    app,
-    client,
-    test_override_in_items,
-    test_override_in_items_with_params,
-    test_override_in_items_with_q,
-)
-
-
-def test_override_in_items_run():
-    test_override_in_items()
-
-
-def test_override_in_items_with_q_run():
-    test_override_in_items_with_q()
-
-
-def test_override_in_items_with_params_run():
-    test_override_in_items_with_params()
-
-
-def test_override_in_users():
-    response = client.get("/users/")
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "message": "Hello Users!",
-        "params": {"q": None, "skip": 5, "limit": 10},
-    }
-
-
-def test_override_in_users_with_q():
-    response = client.get("/users/?q=foo")
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "message": "Hello Users!",
-        "params": {"q": "foo", "skip": 5, "limit": 10},
-    }
-
-
-def test_override_in_users_with_params():
-    response = client.get("/users/?q=foo&skip=100&limit=200")
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "message": "Hello Users!",
-        "params": {"q": "foo", "skip": 5, "limit": 10},
-    }
-
-
-def test_normal_app():
-    app.dependency_overrides = None
-    response = client.get("/items/?q=foo&skip=100&limit=200")
-    assert response.status_code == 200, response.text
-    assert response.json() == {
-        "message": "Hello Items!",
-        "params": {"q": "foo", "skip": 100, "limit": 200},
-    }
diff --git a/tests/test_tutorial/test_websockets/__init__.py b/tests/test_tutorial/test_websockets/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test_tutorial/test_websockets/test_tutorial001.py b/tests/test_tutorial/test_websockets/test_tutorial001.py
deleted file mode 100644
index 1efb5c9..0000000
--- a/tests/test_tutorial/test_websockets/test_tutorial001.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-from squall.websockets import WebSocketDisconnect
-
-from docs_src.websockets.tutorial001 import app
-
-client = TestClient(app)
-
-
-def test_main():
-    response = client.get("/")
-    assert response.status_code == 200, response.text
-    assert b"<!DOCTYPE html>" in response.content
-
-
-def test_websocket():
-    with pytest.raises(WebSocketDisconnect):
-        with client.websocket_connect("/ws") as websocket:
-            message = "Message one"
-            websocket.send_text(message)
-            data = websocket.receive_text()
-            assert data == f"Message text was: {message}"
-            message = "Message two"
-            websocket.send_text(message)
-            data = websocket.receive_text()
-            assert data == f"Message text was: {message}"
diff --git a/tests/test_tutorial/test_websockets/test_tutorial002.py b/tests/test_tutorial/test_websockets/test_tutorial002.py
deleted file mode 100644
index 2c2bf39..0000000
--- a/tests/test_tutorial/test_websockets/test_tutorial002.py
+++ /dev/null
@@ -1,86 +0,0 @@
-import pytest
-from squall.testclient import TestClient
-from squall.websockets import WebSocketDisconnect
-
-from docs_src.websockets.tutorial002 import app
-
-client = TestClient(app)
-
-
-def test_main():
-    response = client.get("/")
-    assert response.status_code == 200, response.text
-    assert b"<!DOCTYPE html>" in response.content
-
-
-def test_websocket_with_cookie():
-    with pytest.raises(WebSocketDisconnect):
-        with client.websocket_connect(
-            "/items/foo/ws", cookies={"session": "fakesession"}
-        ) as websocket:
-            message = "Message one"
-            websocket.send_text(message)
-            data = websocket.receive_text()
-            assert data == "Session cookie or query token value is: fakesession"
-            data = websocket.receive_text()
-            assert data == f"Message text was: {message}, for item ID: foo"
-            message = "Message two"
-            websocket.send_text(message)
-            data = websocket.receive_text()
-            assert data == "Session cookie or query token value is: fakesession"
-            data = websocket.receive_text()
-            assert data == f"Message text was: {message}, for item ID: foo"
-
-
-def test_websocket_with_header():
-    with pytest.raises(WebSocketDisconnect):
-        with client.websocket_connect("/items/bar/ws?token=some-token") as websocket:
-            message = "Message one"
-            websocket.send_text(message)
-            data = websocket.receive_text()
-            assert data == "Session cookie or query token value is: some-token"
-            data = websocket.receive_text()
-            assert data == f"Message text was: {message}, for item ID: bar"
-            message = "Message two"
-            websocket.send_text(message)
-            data = websocket.receive_text()
-            assert data == "Session cookie or query token value is: some-token"
-            data = websocket.receive_text()
-            assert data == f"Message text was: {message}, for item ID: bar"
-
-
-def test_websocket_with_header_and_query():
-    with pytest.raises(WebSocketDisconnect):
-        with client.websocket_connect("/items/2/ws?q=3&token=some-token") as websocket:
-            message = "Message one"
-            websocket.send_text(message)
-            data = websocket.receive_text()
-            assert data == "Session cookie or query token value is: some-token"
-            data = websocket.receive_text()
-            assert data == "Query parameter q is: 3"
-            data = websocket.receive_text()
-            assert data == f"Message text was: {message}, for item ID: 2"
-            message = "Message two"
-            websocket.send_text(message)
-            data = websocket.receive_text()
-            assert data == "Session cookie or query token value is: some-token"
-            data = websocket.receive_text()
-            assert data == "Query parameter q is: 3"
-            data = websocket.receive_text()
-            assert data == f"Message text was: {message}, for item ID: 2"
-
-
-def test_websocket_no_credentials():
-    with pytest.raises(WebSocketDisconnect):
-        with client.websocket_connect("/items/foo/ws"):
-            pytest.fail(
-                "did not raise WebSocketDisconnect on __enter__"
-            )  # pragma: no cover
-
-
-def test_websocket_invalid_data():
-    with pytest.raises(WebSocketDisconnect):
-        with client.websocket_connect("/items/foo/ws?q=bar&token=some-token"):
-            pytest.fail(
-                "did not raise WebSocketDisconnect on __enter__"
-            )  # pragma: no cover
diff --git a/tests/test_tutorial/test_websockets/test_tutorial003.py b/tests/test_tutorial/test_websockets/test_tutorial003.py
deleted file mode 100644
index ff89ca1..0000000
--- a/tests/test_tutorial/test_websockets/test_tutorial003.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from squall.testclient import TestClient
-
-from docs_src.websockets.tutorial003 import app, html
-
-client = TestClient(app)
-
-
-def test_get():
-    response = client.get("/")
-    assert response.text == html
-
-
-def test_websocket_handle_disconnection():
-    with client.websocket_connect("/ws/1234") as connection, client.websocket_connect(
-        "/ws/5678"
-    ) as connection_two:
-        connection.send_text("Hello from 1234")
-        data1 = connection.receive_text()
-        assert data1 == "You wrote: Hello from 1234"
-        data2 = connection_two.receive_text()
-        client1_says = "Client #1234 says: Hello from 1234"
-        assert data2 == client1_says
-        data1 = connection.receive_text()
-        assert data1 == client1_says
-        connection_two.close()
-        data1 = connection.receive_text()
-        assert data1 == "Client #5678 left the chat"
diff --git a/tests/test_union_body.py b/tests/test_union_body.py
deleted file mode 100644
index e05b9a3..0000000
--- a/tests/test_union_body.py
+++ /dev/null
@@ -1,126 +0,0 @@
-from typing import Optional, Union
-
-from pydantic import Field, dataclasses
-from squall import Squall
-from squall.testclient import TestClient
-
-app = Squall()
-
-
-@dataclasses.dataclass
-class Item:
-    name: Optional[str] = None
-
-
-@dataclasses.dataclass
-class OtherItem:
-    price: int = Field(...)
-
-
-@app.post("/items/")
-def save_union_body(item: Union[OtherItem, Item]):
-    return {"item": item}
-
-
-client = TestClient(app)
-
-item_openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Save Union Body",
-                "operationId": "save_union_body_items__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {
-                                "title": "Item",
-                                "anyOf": [
-                                    {"$ref": "#/components/schemas/OtherItem"},
-                                    {"$ref": "#/components/schemas/Item"},
-                                ],
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "OtherItem": {
-                "title": "OtherItem",
-                "required": ["price"],
-                "type": "object",
-                "properties": {"price": {"title": "Price", "type": "integer"}},
-            },
-            "Item": {
-                "title": "Item",
-                "type": "object",
-                "properties": {"name": {"title": "Name", "type": "string"}},
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_item_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == item_openapi_schema
-
-
-def test_post_other_item():
-    response = client.post("/items/", json={"price": 100})
-    assert response.status_code == 200, response.text
-    assert response.json() == {"item": {"price": 100}}
-
-
-def test_post_item():
-    response = client.post("/items/", json={"name": "Foo"})
-    assert response.status_code == 200, response.text
-    assert response.json() == {"item": {"name": "Foo"}}
diff --git a/tests/test_union_inherited_body.py b/tests/test_union_inherited_body.py
deleted file mode 100644
index 47d436d..0000000
--- a/tests/test_union_inherited_body.py
+++ /dev/null
@@ -1,130 +0,0 @@
-from typing import Optional, Union
-
-from pydantic import Field, dataclasses
-from squall import Squall
-from squall.testclient import TestClient
-
-app = Squall()
-
-
-@dataclasses.dataclass
-class Item:
-    name: Optional[str] = None
-
-
-@dataclasses.dataclass
-class ExtendedItem(Item):
-    age: int = Field(...)
-
-
-@app.post("/items/")
-def save_union_different_body(item: Union[ExtendedItem, Item]):
-    return {"item": item}
-
-
-client = TestClient(app)
-
-
-inherited_item_openapi_schema = {
-    "openapi": "3.0.2",
-    "info": {"title": "Squall", "version": "0.1.0"},
-    "paths": {
-        "/items/": {
-            "post": {
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {"application/json": {"schema": {}}},
-                    },
-                    "422": {
-                        "description": "Validation Error",
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "$ref": "#/components/schemas/HTTPValidationError"
-                                }
-                            }
-                        },
-                    },
-                },
-                "summary": "Save Union Different Body",
-                "operationId": "save_union_different_body_items__post",
-                "requestBody": {
-                    "content": {
-                        "application/json": {
-                            "schema": {
-                                "title": "Item",
-                                "anyOf": [
-                                    {"$ref": "#/components/schemas/ExtendedItem"},
-                                    {"$ref": "#/components/schemas/Item"},
-                                ],
-                            }
-                        }
-                    },
-                    "required": True,
-                },
-            }
-        }
-    },
-    "components": {
-        "schemas": {
-            "Item": {
-                "title": "Item",
-                "type": "object",
-                "properties": {"name": {"title": "Name", "type": "string"}},
-            },
-            "ExtendedItem": {
-                "title": "ExtendedItem",
-                "required": ["age"],
-                "type": "object",
-                "properties": {
-                    "name": {"title": "Name", "type": "string"},
-                    "age": {"title": "Age", "type": "integer"},
-                },
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": ["loc", "msg", "type"],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {"type": "string"},
-                    },
-                    "msg": {"title": "Message", "type": "string"},
-                    "type": {"title": "Error Type", "type": "string"},
-                },
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {"$ref": "#/components/schemas/ValidationError"},
-                    }
-                },
-            },
-        }
-    },
-}
-
-
-def test_inherited_item_openapi_schema():
-    response = client.get("/openapi.json")
-    assert response.status_code == 200, response.text
-    assert response.json() == inherited_item_openapi_schema
-
-
-def test_post_extended_item():
-    response = client.post("/items/", json={"name": "Foo", "age": 5})
-    assert response.status_code == 200, response.text
-    assert response.json() == {"item": {"name": "Foo", "age": 5}}
-
-
-def test_post_item():
-    response = client.post("/items/", json={"name": "Foo"})
-    assert response.status_code == 200, response.text
-    assert response.json() == {"item": {"name": "Foo"}}
diff --git a/tests/test_validation/test_head_validation.py b/tests/test_validation/test_head_validation.py
new file mode 100644
index 0000000..855a5b8
--- /dev/null
+++ b/tests/test_validation/test_head_validation.py
@@ -0,0 +1,376 @@
+import typing
+from decimal import Decimal
+
+import pytest
+from squall.params import Cookie, Header, Num, Param, Query, Str
+
+
+def test_no_args(app, client):
+    @app.get("/foo")
+    def foo():
+        return {}
+
+    response = client.get("/foo")
+    assert response.status_code == 200, response.text
+    assert response.json() == {}
+
+
+def test_no_defaults_no_annotation(app, client):
+    @app.get("/no_defaults/no_annotations/{from_path}")
+    def foo(
+        from_path, from_qs=Query(...), from_header=Header(...), from_cookie=Cookie(...)
+    ):
+        return {
+            "from_path": from_path,
+            "from_path_type": type(from_path).__name__,
+            "from_qs": from_qs,
+            "from_qs_type": type(from_qs).__name__,
+            "from_header": from_header,
+            "from_header_type": type(from_header).__name__,
+            "from_cookie": from_cookie,
+            "from_cookie_type": type(from_cookie).__name__,
+        }
+
+    response = client.get("/no_defaults/no_annotations/some_param")
+    assert response.status_code == 400, response.text
+    assert response.json() == {
+        "details": [
+            {"loc": ["query_params", "from_qs"], "msg": "Mandatory field missed"},
+            {"loc": ["headers", "from_header"], "msg": "Mandatory field missed"},
+            {"loc": ["cookies", "from_cookie"], "msg": "Mandatory field missed"},
+        ]
+    }
+
+    response = client.get(
+        "/no_defaults/no_annotations/some_param?from_qs=qs_value",
+        headers={"from_header": "header_value"},
+        cookies={"from_cookie": "cookie_value"},
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "from_path": "some_param",
+        "from_path_type": "str",
+        "from_qs": "qs_value",
+        "from_qs_type": "str",
+        "from_header": "header_value",
+        "from_header_type": "str",
+        "from_cookie": "cookie_value",
+        "from_cookie_type": "str",
+    }
+
+
+def test_defaults_no_annotation(app, client):
+    @app.get("/defaults/no_annotations")
+    def foo(from_qs=Query(None), from_header=Header(None), from_cookie=Cookie(None)):
+        return {
+            "from_qs": from_qs,
+            "from_qs_type": type(from_qs).__name__,
+            "from_header": from_header,
+            "from_header_type": type(from_header).__name__,
+            "from_cookie": from_cookie,
+            "from_cookie_type": type(from_cookie).__name__,
+        }
+
+    response = client.get("/defaults/no_annotations")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "from_qs": None,
+        "from_qs_type": "NoneType",
+        "from_header": None,
+        "from_header_type": "NoneType",
+        "from_cookie": None,
+        "from_cookie_type": "NoneType",
+    }
+
+
+def test_parameter_from_another_origin_name(app, client):
+    @app.get("/from_another/origin_name/{origin_param}")
+    def foo(
+        param=Param(..., origin="origin_param"),
+        qs=Query(..., origin="origin_qs"),
+        header=Header(..., origin="origin_header"),
+        cookie=Cookie(..., origin="origin_cookie"),
+    ):
+        return {
+            "param": param,
+            "param_type": type(param).__name__,
+            "qs": qs,
+            "qs_type": type(qs).__name__,
+            "header": header,
+            "header_type": type(header).__name__,
+            "cookie": cookie,
+            "cookie_type": type(cookie).__name__,
+        }
+
+    response = client.get(
+        "/from_another/origin_name/some_param?origin_qs=qs_value",
+        headers={"origin_header": "header_value"},
+        cookies={"origin_cookie": "cookie_value"},
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "param": "some_param",
+        "param_type": "str",
+        "qs": "qs_value",
+        "qs_type": "str",
+        "header": "header_value",
+        "header_type": "str",
+        "cookie": "cookie_value",
+        "cookie_type": "str",
+    }
+
+
+def test_no_defaults_cast_from_annotation_positive(app, client):
+    @app.get("/no_defaults/cast_from_annotation/{from_path}")
+    def foo(
+        from_path: int,
+        from_qs: float = Query(...),
+        from_header: str = Header(...),
+        from_cookie: bytes = Cookie(...),
+    ):
+        return {
+            "from_path": from_path,
+            "from_path_type": type(from_path).__name__,
+            "from_qs": from_qs,
+            "from_qs_type": type(from_qs).__name__,
+            "from_header": from_header,
+            "from_header_type": type(from_header).__name__,
+            "from_cookie": from_cookie,
+            "from_cookie_type": type(from_cookie).__name__,
+        }
+
+    response = client.get(
+        "/no_defaults/cast_from_annotation/123?from_qs=321",
+        headers={"from_header": "header_value"},
+        cookies={"from_cookie": "cookie_value"},
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "from_path": 123,
+        "from_path_type": "int",
+        "from_qs": 321.0,
+        "from_qs_type": "float",
+        "from_header": "header_value",
+        "from_header_type": "str",
+        "from_cookie": "cookie_value",
+        "from_cookie_type": "bytes",
+    }
+
+
+def test_validate_any_string_positive(app, client):
+    @app.get("/validate/any_string/{from_path}")
+    def foo(
+        from_path: str = Param(..., valid=Str(min_length=5, max_length=20)),
+        from_qs: str = Query(..., valid=Str(min_length=5, max_length=20)),
+        from_header: bytes = Header(..., valid=Str(min_length=5, max_length=20)),
+        from_cookie: bytes = Cookie(..., valid=Str(min_length=5, max_length=20)),
+    ):
+        return {
+            "from_path": from_path,
+            "from_path_type": type(from_path).__name__,
+            "from_qs": from_qs,
+            "from_qs_type": type(from_qs).__name__,
+            "from_header": from_header,
+            "from_header_type": type(from_header).__name__,
+            "from_cookie": from_cookie,
+            "from_cookie_type": type(from_cookie).__name__,
+        }
+
+    response = client.get(
+        "/validate/any_string/12345?from_qs=32132",
+        headers={"from_header": "header_value"},
+        cookies={"from_cookie": "cookie_value"},
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "from_path": "12345",
+        "from_path_type": "str",
+        "from_qs": "32132",
+        "from_qs_type": "str",
+        "from_header": "header_value",
+        "from_header_type": "bytes",
+        "from_cookie": "cookie_value",
+        "from_cookie_type": "bytes",
+    }
+
+
+@pytest.mark.parametrize(
+    "min_length,max_length",
+    [
+        (6, None),
+        (None, 4),
+        (1, 4),
+    ],
+)
+def test_validate_any_string_negative(app, client, min_length, max_length):
+    @app.get("/validate/any_string/{from_path}")
+    def foo(
+        from_path: str = Param(
+            ..., valid=Str(min_length=min_length, max_length=max_length)
+        ),
+        from_qs: str = Query(
+            ..., valid=Str(min_length=min_length, max_length=max_length)
+        ),
+        from_header: bytes = Header(
+            ..., valid=Str(min_length=min_length, max_length=max_length)
+        ),
+        from_cookie: bytes = Cookie(
+            ..., valid=Str(min_length=min_length, max_length=max_length)
+        ),
+    ):
+        return {
+            "from_path": from_path,
+            "from_path_type": type(from_path).__name__,
+            "from_qs": from_qs,
+            "from_qs_type": type(from_qs).__name__,
+            "from_header": from_header,
+            "from_header_type": type(from_header).__name__,
+            "from_cookie": from_cookie,
+            "from_cookie_type": type(from_cookie).__name__,
+        }
+
+    response = client.get(
+        "/validate/any_string/12345?from_qs=12345",
+        headers={"from_header": "12345"},
+        cookies={"from_cookie": "12345"},
+    )
+    assert response.status_code == 400, response.text
+    assert response.json() == {
+        "details": [
+            {
+                "loc": ["path_params", "from_path"],
+                "msg": "Validation error",
+                "val": "12345",
+            },
+            {
+                "loc": ["query_params", "from_qs"],
+                "msg": "Validation error",
+                "val": "12345",
+            },
+            {
+                "loc": ["headers", "from_header"],
+                "msg": "Validation error",
+                "val": "12345",
+            },
+            {
+                "loc": ["cookies", "from_cookie"],
+                "msg": "Validation error",
+                "val": "12345",
+            },
+        ]
+    }
+
+
+def test_validate_numeric_positive(app, client):
+    @app.get("/validate/numeric/{from_path}")
+    def foo(
+        from_path: int = Param(..., valid=Num(ge=5, le=20)),
+        from_qs: float = Query(..., valid=Num(ge=5, le=20)),
+        from_header: Decimal = Header(..., valid=Num(ge=5, le=20)),
+        from_cookie: int = Cookie(..., valid=Num(ge=5, le=20)),
+    ):
+        return {
+            "from_path": from_path,
+            "from_path_type": type(from_path).__name__,
+            "from_qs": from_qs,
+            "from_qs_type": type(from_qs).__name__,
+            "from_header": from_header,
+            "from_header_type": type(from_header).__name__,
+            "from_cookie": from_cookie,
+            "from_cookie_type": type(from_cookie).__name__,
+        }
+
+    response = client.get(
+        "/validate/numeric/15?from_qs=16",
+        headers={"from_header": "14"},
+        cookies={"from_cookie": "17"},
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "from_path": 15,
+        "from_path_type": "int",
+        "from_qs": 16.0,
+        "from_qs_type": "float",
+        "from_header": Decimal(14),
+        "from_header_type": "Decimal",
+        "from_cookie": 17,
+        "from_cookie_type": "int",
+    }
+
+
+@pytest.mark.parametrize(
+    "ge,le",
+    [
+        (20, None),
+        (None, 5),
+        (1, 4),
+    ],
+)
+def test_validate_numeric_negative(app, client, ge, le):
+    @app.get("/validate/numeric/{from_path}")
+    def foo(
+        from_path: int = Param(..., valid=Num(ge=ge, le=le)),
+        from_qs: float = Query(..., valid=Num(ge=ge, le=le)),
+        from_header: Decimal = Header(..., valid=Num(ge=ge, le=le)),
+        from_cookie: int = Cookie(..., valid=Num(ge=ge, le=le)),
+    ):
+        return {
+            "from_path": from_path,
+            "from_path_type": type(from_path).__name__,
+            "from_qs": from_qs,
+            "from_qs_type": type(from_qs).__name__,
+            "from_header": from_header,
+            "from_header_type": type(from_header).__name__,
+            "from_cookie": from_cookie,
+            "from_cookie_type": type(from_cookie).__name__,
+        }
+
+    response = client.get(
+        "/validate/numeric/15?from_qs=16",
+        headers={"from_header": "14"},
+        cookies={"from_cookie": "17"},
+    )
+    assert response.status_code == 400, response.text
+    assert response.json() == {
+        "details": [
+            {"loc": ["path_params", "from_path"], "msg": "Validation error", "val": 15},
+            {
+                "loc": ["query_params", "from_qs"],
+                "msg": "Validation error",
+                "val": 16.0,
+            },
+            {"loc": ["headers", "from_header"], "msg": "Validation error", "val": 14.0},
+            {"loc": ["cookies", "from_cookie"], "msg": "Validation error", "val": 17},
+        ]
+    }
+
+
+def test_list_annotation(app, client):
+    @app.get("/validate/any_string/{from_path}")
+    def foo(
+        from_qs: typing.List[str] = Query(...),
+        from_qs2: typing.Optional[typing.List[bytes]] = Query(...),
+    ):
+        return {
+            "from_qs": from_qs,
+            "from_qs_type": type(from_qs).__name__,
+            "from_qs_element_type": type(from_qs[0]).__name__,
+            "from_qs2": from_qs2,
+            "from_qs2_type": type(from_qs2).__name__,
+            "from_qs2_element_type": type(from_qs2[0]).__name__,
+        }
+
+    response = client.get(
+        "/validate/any_string/12345?"
+        "from_qs=11111&from_qs=22222&"
+        "from_qs2=11111&from_qs2=22222"
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "from_qs": ["11111", "22222"],
+        "from_qs2": ["11111", "22222"],
+        "from_qs2_element_type": "bytes",
+        "from_qs2_type": "list",
+        "from_qs_element_type": "str",
+        "from_qs_type": "list",
+    }
diff --git a/tests/test_validation/test_head_validator_class.py b/tests/test_validation/test_head_validator_class.py
new file mode 100644
index 0000000..d73cb1b
--- /dev/null
+++ b/tests/test_validation/test_head_validator_class.py
@@ -0,0 +1,218 @@
+import typing
+from dataclasses import dataclass, field
+from decimal import Decimal
+
+from squall.validators.head import Validator
+
+
+@dataclass
+class Request:
+    path_params: typing.Dict[str, typing.Any] = field(default_factory=dict)
+    query_params: typing.Dict[str, typing.Any] = field(default_factory=dict)
+    headers: typing.Dict[str, typing.Any] = field(default_factory=dict)
+    cookies: typing.Dict[str, typing.Any] = field(default_factory=dict)
+
+
+def test_numeric_with_conversion():
+    v = Validator(
+        args=["request"],
+        convertors={"int": int, "float": float, "decimal": Decimal},
+    )
+    v.add_rule("numeric", "path_params", "numeric1", gt=20, le=50, convert="decimal")
+    v.add_rule("numeric", "path_params", "numeric2", gt=20, le=50, convert="int")
+    v.add_rule("numeric", "path_params", "numeric3", gt=20, le=50, convert="float")
+    validator = v.build()
+
+    request = Request(path_params={"numeric1": 30, "numeric2": 30, "numeric3": 30})
+    assert validator(request) == (
+        {"numeric1": Decimal(30), "numeric2": 30, "numeric3": 30.0},
+        [],
+    )
+
+    request = Request(path_params={"numeric1": 19, "numeric2": 19, "numeric3": 19})
+    assert validator(request) == (
+        {},
+        [
+            ("path_params", "numeric1", "Validation error", Decimal("19")),
+            ("path_params", "numeric2", "Validation error", 19),
+            ("path_params", "numeric3", "Validation error", 19.0),
+        ],
+    )
+
+    request = Request(path_params={"numeric1": 51, "numeric2": 51, "numeric3": 51})
+    assert validator(request) == (
+        {},
+        [
+            ("path_params", "numeric1", "Validation error", Decimal("51")),
+            ("path_params", "numeric2", "Validation error", 51),
+            ("path_params", "numeric3", "Validation error", 51.0),
+        ],
+    )
+
+
+def test_numeric_without_conversion():
+    v = Validator(args=["request"], convertors={})
+    v.add_rule("numeric", "path_params", "numeric1", gt=20, le=50)
+    v.add_rule("numeric", "path_params", "numeric2", gt=20, le=50)
+    v.add_rule("numeric", "path_params", "numeric3", gt=20, le=50)
+    validator = v.build()
+
+    request = Request(path_params={"numeric1": 30, "numeric2": 30, "numeric3": 30})
+    assert validator(request) == ({"numeric1": 30, "numeric2": 30, "numeric3": 30}, [])
+
+    request = Request(
+        path_params={"numeric1": Decimal(30), "numeric2": 30.0, "numeric3": 30}
+    )
+    assert validator(request) == (
+        {"numeric1": Decimal(30), "numeric2": 30.0, "numeric3": 30},
+        [],
+    )
+
+    request = Request(path_params={"numeric1": 19, "numeric2": 19, "numeric3": 19})
+    assert validator(request) == (
+        {},
+        [
+            ("path_params", "numeric1", "Validation error", 19),
+            ("path_params", "numeric2", "Validation error", 19),
+            ("path_params", "numeric3", "Validation error", 19),
+        ],
+    )
+
+    request = Request(path_params={"numeric1": 51, "numeric2": 51, "numeric3": 51})
+    assert validator(request) == (
+        {},
+        [
+            ("path_params", "numeric1", "Validation error", 51),
+            ("path_params", "numeric2", "Validation error", 51),
+            ("path_params", "numeric3", "Validation error", 51),
+        ],
+    )
+
+    request = Request()
+    assert validator(request) == (
+        {},
+        [
+            ("path_params", "numeric1", "Mandatory field missed", Ellipsis),
+            ("path_params", "numeric2", "Mandatory field missed", Ellipsis),
+            ("path_params", "numeric3", "Mandatory field missed", Ellipsis),
+        ],
+    )
+
+
+def test_strings():
+    v = Validator(
+        args=["request"],
+        convertors={
+            "str": lambda a: a.decode("utf-8") if type(a) == bytes else str(a),
+            "bytes": lambda a: str(a).encode("utf-8") if type(a) != bytes else a,
+        },
+    )
+    v.add_rule(
+        "string", "path_params", "string1", min_length=3, max_length=5, convert="str"
+    )
+    v.add_rule(
+        "string", "path_params", "string2", min_length=3, max_length=5, convert="bytes"
+    )
+
+    validator = v.build()
+    request = Request(path_params={"string1": "303", "string2": "403"})
+    assert validator(request) == ({"string1": "303", "string2": b"403"}, [])
+
+    request = Request(path_params={"string1": 303, "string2": 403})
+    assert validator(request) == ({"string1": "303", "string2": b"403"}, [])
+
+    request = Request(path_params={"string1": "aa", "string2": "aaaaaa"})
+    assert validator(request) == (
+        {},
+        [
+            ("path_params", "string1", "Validation error", "aa"),
+            ("path_params", "string2", "Validation error", b"aaaaaa"),
+        ],
+    )
+
+    request = Request()
+    assert validator(request) == (
+        {},
+        [
+            ("path_params", "string1", "Mandatory field missed", Ellipsis),
+            ("path_params", "string2", "Mandatory field missed", Ellipsis),
+        ],
+    )
+
+
+def test_no_rules():
+    v = Validator(args=["request"], convertors={})
+
+    validator = v.build()
+    request = Request(path_params={"put": "any", "noise": "here"})
+    assert validator(request) == ({}, [])
+
+
+def test_multiple_sources():
+    v = Validator(args=["request"], convertors={})
+    validator = v.build()
+    request = Request(path_params={"put": "any"}, headers={"noise": "here"})
+    assert validator(request) == ({}, [])
+
+    v = Validator(args=["request"], convertors={"decimal": Decimal, "str": str})
+    v.add_rule("numeric", "path_params", "numeric1", gt=20, le=50, convert="decimal")
+    v.add_rule(
+        "string", "headers", "string1", min_length=3, max_length=5, convert="str"
+    )
+    validator = v.build()
+
+    request = Request(path_params={"numeric1": 20}, headers={"string1": "str"})
+    assert validator(request) == (
+        {"string1": "str"},
+        [("path_params", "numeric1", "Validation error", Decimal("20"))],
+    )
+
+
+def test_default():
+    v = Validator(args=["request"], convertors={})
+    v.add_rule("numeric", "path_params", "numeric1", default=1)
+    v.add_rule("string", "headers", "string1", default="default_str")
+    validator = v.build()
+
+    request = Request()
+    assert validator(request) == ({"string1": "default_str", "numeric1": 1}, [])
+
+
+def test_origin_key():
+    v = Validator(args=["request"], convertors={})
+    v.add_rule("numeric", "query_params", name="n1", key="numeric1")
+    v.add_rule("numeric", "query_params", name="n2", key="numeric2")
+    v.add_rule("numeric", "query_params", name="n3", key="numeric3")
+    validator = v.build()
+
+    request = Request(query_params={"numeric1": 30, "numeric2": 30, "numeric3": 30})
+    assert validator(request) == ({"n1": 30, "n2": 30, "n3": 30}, [])
+
+
+def test_lists():
+    v = Validator(args=["request"], convertors={})
+    v.add_rule(None, "query_params", "query1", as_list=True)
+    validator = v.build()
+    from starlette.datastructures import MultiDict
+
+    qs = MultiDict()
+    request = Request(query_params=qs)
+    assert validator(request) == ({"query1": []}, [])
+
+    v = Validator(args=["request"], convertors={"int": int})
+    v.add_rule(None, "query_params", "query1", as_list=True)
+    v.add_rule(None, "query_params", "query2", as_list=True)
+    v.add_rule(None, "query_params", "query3", as_list=True, convert="int")
+    validator = v.build()
+
+    qs = MultiDict()
+    qs.append("query1", "value1")
+    qs.append("query2", "value1")
+    qs.append("query2", "value2")
+    qs.append("query3", "1")
+    qs.append("query3", "2")
+    request = Request(query_params=qs)
+    assert validator(request) == (
+        {"query1": ["value1"], "query2": ["value1", "value2"], "query3": [1, 2]},
+        [],
+    )
diff --git a/tests/test_validation/test_inputs.py b/tests/test_validation/test_inputs.py
deleted file mode 100644
index b05f18f..0000000
--- a/tests/test_validation/test_inputs.py
+++ /dev/null
@@ -1,150 +0,0 @@
-from decimal import Decimal
-
-from squall.validators.inputs import Validator
-
-
-def test_numeric_with_conversion():
-    v = Validator(
-        args=["param"],
-        convertors={"int": int, "float": float, "decimal": Decimal},
-    )
-    v.add_rule("numeric", "param", "numeric1", gt=20, le=50, convert="decimal")
-    v.add_rule("numeric", "param", "numeric2", gt=20, le=50, convert="int")
-    v.add_rule("numeric", "param", "numeric3", gt=20, le=50, convert="float")
-    validator = v.build()
-
-    param = {"numeric1": 30, "numeric2": 30, "numeric3": 30}
-    assert validator(param) == (
-        {"numeric1": Decimal(30), "numeric2": 30, "numeric3": 30.0},
-        [],
-    )
-
-    param = {"numeric1": 19, "numeric2": 19, "numeric3": 19}
-    assert validator(param) == (
-        {"numeric1": Decimal("19"), "numeric2": 19, "numeric3": 19.0},
-        [
-            ("numeric1", "Validation error"),
-            ("numeric2", "Validation error"),
-            ("numeric3", "Validation error"),
-        ],
-    )
-
-    param = {"numeric1": 51, "numeric2": 51, "numeric3": 51}
-    assert validator(param) == (
-        {"numeric1": 51, "numeric2": 51, "numeric3": 51},
-        [
-            ("numeric1", "Validation error"),
-            ("numeric2", "Validation error"),
-            ("numeric3", "Validation error"),
-        ],
-    )
-
-
-def test_numeric_without_conversion():
-    v = Validator(args=["param"], convertors={})
-    v.add_rule("numeric", "param", "numeric1", gt=20, le=50)
-    v.add_rule("numeric", "param", "numeric2", gt=20, le=50)
-    v.add_rule("numeric", "param", "numeric3", gt=20, le=50)
-    validator = v.build()
-
-    param = {"numeric1": 30, "numeric2": 30, "numeric3": 30}
-    assert validator(param) == ({"numeric1": 30, "numeric2": 30, "numeric3": 30}, [])
-
-    param = {"numeric1": Decimal(30), "numeric2": 30.0, "numeric3": 30}
-    assert validator(param) == (
-        {"numeric1": Decimal(30), "numeric2": 30.0, "numeric3": 30},
-        [],
-    )
-
-    param = {"numeric1": 19, "numeric2": 19, "numeric3": 19}
-    assert validator(param) == (
-        {"numeric1": 19, "numeric2": 19, "numeric3": 19},
-        [
-            ("numeric1", "Validation error"),
-            ("numeric2", "Validation error"),
-            ("numeric3", "Validation error"),
-        ],
-    )
-
-    param = {"numeric1": 51, "numeric2": 51, "numeric3": 51}
-    assert validator(param) == (
-        {"numeric1": 51, "numeric2": 51, "numeric3": 51},
-        [
-            ("numeric1", "Validation error"),
-            ("numeric2", "Validation error"),
-            ("numeric3", "Validation error"),
-        ],
-    )
-
-    param = {}
-    assert validator(param) == (
-        {"numeric1": None, "numeric2": None, "numeric3": None},
-        [
-            ("numeric1", "Can't be None"),
-            ("numeric2", "Can't be None"),
-            ("numeric3", "Can't be None"),
-        ],
-    )
-
-
-def test_strings():
-    v = Validator(
-        args=["param"],
-        convertors={
-            "str": lambda a: a.decode("utf-8") if type(a) == bytes else str(a),
-            "bytes": lambda a: str(a).encode("utf-8") if type(a) != bytes else a,
-        },
-    )
-    v.add_rule("string", "param", "string1", min_length=3, max_length=5, convert="str")
-    v.add_rule(
-        "string", "param", "string2", min_length=3, max_length=5, convert="bytes"
-    )
-
-    validator = v.build()
-    param = {"string1": "303", "string2": "403"}
-    assert validator(param) == ({"string1": "303", "string2": b"403"}, [])
-
-    param = {"string1": 303, "string2": 403}
-    assert validator(param) == ({"string1": "303", "string2": b"403"}, [])
-
-    param = {"string1": "aa", "string2": "aaaaaa"}
-    assert validator(param) == (
-        {"string1": "aa", "string2": b"aaaaaa"},
-        [
-            ("string1", "Validation error"),
-            ("string2", "Validation error"),
-        ],
-    )
-
-    param = {}
-    assert validator(param) == (
-        {"string1": None, "string2": None},
-        [("string1", "Can't be None"), ("string2", "Can't be None")],
-    )
-
-
-def test_no_rules():
-    v = Validator(args=["param"], convertors={})
-
-    validator = v.build()
-    param = {"put": "any", "noise": "here"}
-    assert validator(param) == ({}, [])
-
-
-def test_multiple_sources():
-    v = Validator(args=["param", "header"], convertors={})
-    validator = v.build()
-    param = {"put": "any"}
-    header = {"noise": "here"}
-    assert validator(param, header) == ({}, [])
-
-    v = Validator(args=["param", "header"], convertors={"decimal": Decimal, "str": str})
-    v.add_rule("numeric", "param", "numeric1", gt=20, le=50, convert="decimal")
-    v.add_rule("string", "header", "string1", min_length=3, max_length=5, convert="str")
-    validator = v.build()
-    param = {"numeric1": 20}
-    header = {"string1": "str"}
-    assert validator(param, header) == (
-        {"numeric1": Decimal("20"), "string1": "str"},
-        [("numeric1", "Validation error")],
-    )
diff --git a/tests/test_tutorial/__init__.py b/tests/test_validation/test_utils.py
similarity index 100%
rename from tests/test_tutorial/__init__.py
rename to tests/test_validation/test_utils.py