Bump supported fastapi versions (#1110)

* Bump supported fastapi version to <=0.97, change all fastapi tests from starlette client to httpx.AsyncClient

* Add lifecycle manager to fastapi tests

* Fix coverage

* Add python 3.11 to test suite, bump version

Author: collerek

.github/workflows/test-package.yml

@@ -17,7 +17,7 @@ jobs:
     if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != 'collerek/ormar'
     strategy:
       matrix:
-        python-version: [3.7, 3.8, 3.9, "3.10"]
+        python-version: [3.7, 3.8, 3.9, "3.10", 3.11]
       fail-fast: false
     services:
       mysql:
@@ -49,7 +49,7 @@ jobs:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies
       run: |
-        python -m pip install poetry==1.4.1
+        python -m pip install poetry==1.4.2
         poetry install --extras "all"
       env:
         POETRY_VIRTUALENVS_CREATE: false

benchmarks/test_benchmark_init.py

@@ -21,7 +21,7 @@ async def initialize_models(num_models: int):
         ]
         assert len(authors) == num_models
 
-    initialize_models(num_models)
+    await initialize_models(num_models)
 
 
 @pytest.mark.parametrize("num_models", [10, 20, 40])
@@ -30,7 +30,7 @@ async def test_initializing_models_with_related_models(aio_benchmark, num_models
     async def initialize_models_with_related_models(
         author: Author, publisher: Publisher, num_models: int
     ):
-        books = [
+        _ = [
             Book(
                 author=author,
                 publisher=publisher,
@@ -43,6 +43,6 @@ async def initialize_models_with_related_models(
     author = await Author(name="Author", score=10).save()
     publisher = await Publisher(name="Publisher", prestige=random.randint(0, 10)).save()
 
-    ids = initialize_models_with_related_models(
+    _ = initialize_models_with_related_models(
         author=author, publisher=publisher, num_models=num_models
     )

benchmarks/test_benchmark_update.py

@@ -18,7 +18,7 @@ async def test_updating_models_individually(
     @aio_benchmark
     async def update(authors: List[Author]):
         for author in authors:
-            a = await author.update(
+            _ = await author.update(
                 name="".join(random.sample(string.ascii_letters, 5))
             )
 

ormar/models/newbasemodel.py

@@ -18,7 +18,6 @@
     Union,
     cast,
 )
-import functools
 
 import databases
 import pydantic
@@ -242,14 +241,18 @@ def _update_relation_cache(self, prev_hash: int, new_hash: int) -> None:
         :param new_hash: The hash to update to
         :type new_hash: int
         """
+
         def _update_cache(relations: List[Relation], recurse: bool = True) -> None:
             for relation in relations:
                 relation_proxy = relation.get()
 
                 if hasattr(relation_proxy, "update_cache"):
                     relation_proxy.update_cache(prev_hash, new_hash)  # type: ignore
                 elif recurse and hasattr(relation_proxy, "_orm"):
-                    _update_cache(relation_proxy._orm._relations.values(), recurse=False)  # type: ignore
+                    _update_cache(
+                        relation_proxy._orm._relations.values(),  # type: ignore
+                        recurse=False,
+                    )
 
         _update_cache(list(self._orm._relations.values()))
 

ormar/relations/relation.py

@@ -133,8 +133,8 @@ def _find_existing(
             return None
         else:
             # We need to clear the weakrefs that don't point to anything anymore
-            # There's an assumption here that if some of the related models went out of scope,
-            # then they all did, so we can just check the first one
+            # There's an assumption here that if some of the related models
+            # went out of scope, then they all did, so we can just check the first one
             try:
                 self.related_models[0].__repr__.__self__
                 return self.related_models.index(child)

ormar/relations/relation_proxy.py

@@ -145,7 +145,8 @@ def pop(self, index: SupportsIndex = 0) -> T:
         """
         item = self[index]
 
-        # Try to delete it, but do it the long way if weakly-referenced thing doesn't exist
+        # Try to delete it, but do it a long way
+        # if weakly-referenced thing doesn't exist
         try:
             self._relation_cache.pop(item.__hash__())
         except ReferenceError:

poetry.lock

@@ -3,8 +3,8 @@ name = "ormar"
 
 [tool.poetry]
 name = "ormar"
-version = "0.12.1"
-description = "A simple async ORM with fastapi in mind and pydantic validation."
+version = "0.12.2"
+description = "An async ORM with fastapi in mind and pydantic validation."
 authors = ["Radosław Drążkiewicz <collerek@gmail.com>"]
 license = "MIT"
 readme = "README.md"
@@ -56,6 +56,7 @@ psycopg2-binary = { version = "^2.9.1", optional = true }
 mysqlclient = { version = "^2.1.0", optional = true }
 PyMySQL = { version = ">=0.9", optional = true }
 
+
 [tool.poetry.dependencies.orjson]
 version = ">=3.6.4"
 optional = true
@@ -75,7 +76,7 @@ pytest = "^7.3.1"
 pytest-cov = "^4.0.0"
 codecov = "^2.1.13"
 pytest-asyncio = "^0.21.0"
-fastapi = ">=0.70.1,<0.86"
+fastapi = ">=0.70.1,<=0.97"
 flake8 = "^3.9.2"
 flake8-black = "^0.3.6"
 flake8-bugbear = "^23.3.12"
@@ -137,6 +138,10 @@ all = [
     "cryptography",
 ]
 
+[tool.poetry.group.dev.dependencies]
+httpx = "^0.24.1"
+asgi-lifespan = "^2.1.0"
+
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"

pyproject.toml

@@ -6,8 +6,9 @@
 import pydantic
 import pytest
 import sqlalchemy
+from asgi_lifespan import LifespanManager
 from fastapi import FastAPI
-from starlette.testclient import TestClient
+from httpx import AsyncClient
 
 import ormar
 from ormar import post_save, property_field
@@ -153,34 +154,35 @@ async def create_user7(user: RandomModel):
     return await user.save()
 
 
-def test_excluding_fields_in_endpoints():
-    client = TestClient(app)
-    with client as client:
+@pytest.mark.asyncio
+async def test_excluding_fields_in_endpoints():
+    client = AsyncClient(app=app, base_url="http://testserver")
+    async with client as client, LifespanManager(app):
         user = {
             "email": "test@domain.com",
             "password": "^*^%A*DA*IAAA",
             "first_name": "John",
             "last_name": "Doe",
         }
-        response = client.post("/users/", json=user)
+        response = await client.post("/users/", json=user)
         created_user = User(**response.json())
         assert created_user.pk is not None
         assert created_user.password is None
 
         user2 = {"email": "test@domain.com", "first_name": "John", "last_name": "Doe"}
 
-        response = client.post("/users/", json=user2)
+        response = await client.post("/users/", json=user2)
         created_user = User(**response.json())
         assert created_user.pk is not None
         assert created_user.password is None
 
-        response = client.post("/users2/", json=user)
+        response = await client.post("/users2/", json=user)
         created_user2 = User(**response.json())
         assert created_user2.pk is not None
         assert created_user2.password is None
 
         # response has only 3 fields from UserBase
-        response = client.post("/users3/", json=user)
+        response = await client.post("/users3/", json=user)
         assert list(response.json().keys()) == ["email", "first_name", "last_name"]
 
         timestamp = datetime.datetime.now()
@@ -192,7 +194,7 @@ def test_excluding_fields_in_endpoints():
             "last_name": "Doe",
             "timestamp": str(timestamp),
         }
-        response = client.post("/users4/", json=user3)
+        response = await client.post("/users4/", json=user3)
         assert list(response.json().keys()) == [
             "id",
             "email",
@@ -209,7 +211,7 @@ def test_excluding_fields_in_endpoints():
         assert isinstance(user_instance.timestamp, datetime.datetime)
         assert user_instance.timestamp == timestamp
 
-        response = client.post("/users4/", json=user3)
+        response = await client.post("/users4/", json=user3)
         assert list(response.json().keys()) == [
             "id",
             "email",
@@ -226,11 +228,12 @@ def test_excluding_fields_in_endpoints():
         )
 
 
-def test_adding_fields_in_endpoints():
-    client = TestClient(app)
-    with client as client:
+@pytest.mark.asyncio
+async def test_adding_fields_in_endpoints():
+    client = AsyncClient(app=app, base_url="http://testserver")
+    async with client as client, LifespanManager(app):
         user3 = {"last_name": "Test", "full_name": "deleted"}
-        response = client.post("/random/", json=user3)
+        response = await client.post("/random/", json=user3)
         assert list(response.json().keys()) == [
             "id",
             "password",
@@ -242,7 +245,7 @@ def test_adding_fields_in_endpoints():
         assert response.json().get("full_name") == "John Test"
 
         user3 = {"last_name": "Test"}
-        response = client.post("/random/", json=user3)
+        response = await client.post("/random/", json=user3)
         assert list(response.json().keys()) == [
             "id",
             "password",
@@ -254,11 +257,12 @@ def test_adding_fields_in_endpoints():
         assert response.json().get("full_name") == "John Test"
 
 
-def test_adding_fields_in_endpoints2():
-    client = TestClient(app)
-    with client as client:
+@pytest.mark.asyncio
+async def test_adding_fields_in_endpoints2():
+    client = AsyncClient(app=app, base_url="http://testserver")
+    async with client as client, LifespanManager(app):
         user3 = {"last_name": "Test"}
-        response = client.post("/random2/", json=user3)
+        response = await client.post("/random2/", json=user3)
         assert list(response.json().keys()) == [
             "id",
             "password",
@@ -270,18 +274,19 @@ def test_adding_fields_in_endpoints2():
         assert response.json().get("full_name") == "John Test"
 
 
-def test_excluding_property_field_in_endpoints2():
+@pytest.mark.asyncio
+async def test_excluding_property_field_in_endpoints2():
 
     dummy_registry = {}
 
     @post_save(RandomModel)
     async def after_save(sender, instance, **kwargs):
         dummy_registry[instance.pk] = instance.dict()
 
-    client = TestClient(app)
-    with client as client:
+    client = AsyncClient(app=app, base_url="http://testserver")
+    async with client as client, LifespanManager(app):
         user3 = {"last_name": "Test"}
-        response = client.post("/random3/", json=user3)
+        response = await client.post("/random3/", json=user3)
         assert list(response.json().keys()) == [
             "id",
             "password",

tests/test_exclude_include_dict/test_excluding_fields_in_fastapi.py

@@ -6,8 +6,9 @@
 import databases
 import pytest
 import sqlalchemy
+from asgi_lifespan import LifespanManager
 from fastapi import FastAPI
-from starlette.testclient import TestClient
+from httpx import AsyncClient
 
 import ormar
 from tests.settings import DATABASE_URL
@@ -78,16 +79,17 @@ def create_test_database():
     metadata.drop_all(engine)
 
 
-def test_read_main():
-    client = TestClient(app)
-    with client as client:
-        response = client.post(
+@pytest.mark.asyncio
+async def test_read_main():
+    client = AsyncClient(app=app, base_url="http://testserver")
+    async with client as client, LifespanManager(app):
+        response = await client.post(
             "/things",
-            data=json.dumps({"bt": base64.b64encode(blob3).decode()}),
+            json={"bt": base64.b64encode(blob3).decode()},
             headers=headers,
         )
         assert response.status_code == 200
-        response = client.get("/things")
+        response = await client.get("/things")
         assert response.json()[0]["bt"] == base64.b64encode(blob3).decode()
         thing = BinaryThing(**response.json()[0])
         assert thing.__dict__["bt"] == blob3