ugly but working - to refactor

tests/test_columns.py

@@ -1,5 +1,4 @@
 import datetime
-import os
 
 import databases
 import pydantic

tests/test_default_model_order.py

@@ -0,0 +1,113 @@
+from typing import Optional
+
+import databases
+import pytest
+import sqlalchemy
+
+import ormar
+from tests.settings import DATABASE_URL
+
+database = databases.Database(DATABASE_URL)
+metadata = sqlalchemy.MetaData()
+
+
+class BaseMeta(ormar.ModelMeta):
+    metadata = metadata
+    database = database
+
+
+class Author(ormar.Model):
+    class Meta(BaseMeta):
+        tablename = "authors"
+        order_by = ["-name"]
+
+    id: int = ormar.Integer(primary_key=True)
+    name: str = ormar.String(max_length=100)
+
+
+class Book(ormar.Model):
+    class Meta(BaseMeta):
+        tablename = "books"
+        order_by = ["year", "-ranking"]
+
+    id: int = ormar.Integer(primary_key=True)
+    author: Optional[Author] = ormar.ForeignKey(Author)
+    title: str = ormar.String(max_length=100)
+    year: int = ormar.Integer(nullable=True)
+    ranking: int = ormar.Integer(nullable=True)
+
+
+@pytest.fixture(autouse=True, scope="module")
+def create_test_database():
+    engine = sqlalchemy.create_engine(DATABASE_URL)
+    metadata.drop_all(engine)
+    metadata.create_all(engine)
+    yield
+    metadata.drop_all(engine)
+
+
+@pytest.fixture(autouse=True, scope="function")
+async def cleanup():
+    await Book.objects.delete(each=True)
+    await Author.objects.delete(each=True)
+
+
+@pytest.mark.asyncio
+async def test_default_orders_is_applied():
+    async with database:
+        tolkien = await Author(name="J.R.R. Tolkien").save()
+        sapkowski = await Author(name="Andrzej Sapkowski").save()
+        king = await Author(name="Stephen King").save()
+        lewis = await Author(name="C.S Lewis").save()
+
+        authors = await Author.objects.all()
+        assert authors[0] == king
+        assert authors[1] == tolkien
+        assert authors[2] == lewis
+        assert authors[3] == sapkowski
+
+        authors = await Author.objects.order_by("name").all()
+        assert authors[3] == king
+        assert authors[2] == tolkien
+        assert authors[1] == lewis
+        assert authors[0] == sapkowski
+
+
+@pytest.mark.asyncio
+async def test_default_orders_is_applied_on_related():
+    async with database:
+        tolkien = await Author(name="J.R.R. Tolkien").save()
+        silmarillion = await Book(
+            author=tolkien, title="The Silmarillion", year=1977
+        ).save()
+        lotr = await Book(
+            author=tolkien, title="The Lord of the Rings", year=1955
+        ).save()
+        hobbit = await Book(author=tolkien, title="The Hobbit", year=1933).save()
+
+        await tolkien.books.all()
+        assert tolkien.books[0] == hobbit
+        assert tolkien.books[1] == lotr
+        assert tolkien.books[2] == silmarillion
+
+        await tolkien.books.order_by("-title").all()
+        assert tolkien.books[2] == hobbit
+        assert tolkien.books[1] == lotr
+        assert tolkien.books[0] == silmarillion
+
+
+@pytest.mark.asyncio
+async def test_default_orders_is_applied_on_related_two_fields():
+    async with database:
+        sanders = await Author(name="Brandon Sanderson").save()
+        twok = await Book(
+            author=sanders, title="The Way of Kings", year=2010, ranking=10
+        ).save()
+        bret = await Author(name="Peter V. Bret").save()
+        tds = await Book(
+            author=bret, title="The Desert Spear", year=2010, ranking=9
+        ).save()
+
+        books = await Book.objects.all()
+        assert books[0] == twok
+        assert books[1] == tds

tests/test_default_relation_order.py

@@ -0,0 +1,149 @@
+from typing import List, Optional
+from uuid import UUID, uuid4
+
+import databases
+import pytest
+import sqlalchemy
+
+import ormar
+from tests.settings import DATABASE_URL
+
+database = databases.Database(DATABASE_URL)
+metadata = sqlalchemy.MetaData()
+
+
+class BaseMeta(ormar.ModelMeta):
+    metadata = metadata
+    database = database
+
+
+class Author(ormar.Model):
+    class Meta(BaseMeta):
+        tablename = "authors"
+
+    id: int = ormar.Integer(primary_key=True)
+    name: str = ormar.String(max_length=100)
+
+
+class Book(ormar.Model):
+    class Meta(BaseMeta):
+        tablename = "books"
+
+    id: int = ormar.Integer(primary_key=True)
+    author: Optional[Author] = ormar.ForeignKey(
+        Author, orders_by=["name"], related_orders_by=["-year"]
+    )
+    title: str = ormar.String(max_length=100)
+    year: int = ormar.Integer(nullable=True)
+    ranking: int = ormar.Integer(nullable=True)
+
+
+class Animal(ormar.Model):
+    class Meta(BaseMeta):
+        tablename = "animals"
+
+    id: UUID = ormar.UUID(primary_key=True, default=uuid4)
+    name: str = ormar.String(max_length=200)
+    specie: str = ormar.String(max_length=200)
+
+
+class Human(ormar.Model):
+    class Meta(BaseMeta):
+        tablename = "humans"
+
+    id: UUID = ormar.UUID(primary_key=True, default=uuid4)
+    name: str = ormar.Text(default="")
+    pets: List[Animal] = ormar.ManyToMany(
+        Animal,
+        related_name="care_takers",
+        orders_by=["specie", "-name"],
+        related_orders_by=["name"],
+    )
+
+
+@pytest.fixture(autouse=True, scope="module")
+def create_test_database():
+    engine = sqlalchemy.create_engine(DATABASE_URL)
+    metadata.drop_all(engine)
+    metadata.create_all(engine)
+    yield
+    metadata.drop_all(engine)
+
+
+@pytest.fixture(autouse=True, scope="function")
+async def cleanup():
+    await Book.objects.delete(each=True)
+    await Author.objects.delete(each=True)
+
+
+@pytest.mark.asyncio
+async def test_default_orders_is_applied_from_reverse_relation():
+    async with database:
+        tolkien = await Author(name="J.R.R. Tolkien").save()
+        hobbit = await Book(author=tolkien, title="The Hobbit", year=1933).save()
+        silmarillion = await Book(
+            author=tolkien, title="The Silmarillion", year=1977
+        ).save()
+        lotr = await Book(
+            author=tolkien, title="The Lord of the Rings", year=1955
+        ).save()
+
+        tolkien = await Author.objects.select_related("books").get()
+        assert tolkien.books[2] == hobbit
+        assert tolkien.books[1] == lotr
+        assert tolkien.books[0] == silmarillion
+
+
+@pytest.mark.asyncio
+async def test_default_orders_is_applied_from_relation():
+    async with database:
+        bret = await Author(name="Peter V. Bret").save()
+        tds = await Book(
+            author=bret, title="The Desert Spear", year=2010, ranking=9
+        ).save()
+        sanders = await Author(name="Brandon Sanderson").save()
+        twok = await Book(
+            author=sanders, title="The Way of Kings", year=2010, ranking=10
+        ).save()
+
+        books = await Book.objects.order_by("year").select_related("author").all()
+        assert books[0] == twok
+        assert books[1] == tds
+
+
+@pytest.mark.asyncio
+async def test_default_orders_is_applied_from_relation_on_m2m():
+    async with database:
+        alice = await Human(name="Alice").save()
+
+        spot = await Animal(name="Spot", specie="Cat").save()
+        zkitty = await Animal(name="ZKitty", specie="Cat").save()
+        noodle = await Animal(name="Noodle", specie="Anaconda").save()
+
+        await alice.pets.add(noodle)
+        await alice.pets.add(spot)
+        await alice.pets.add(zkitty)
+
+        await alice.load_all()
+        assert alice.pets[0] == noodle
+        assert alice.pets[1] == zkitty
+        assert alice.pets[2] == spot
+
+
+@pytest.mark.asyncio
+async def test_default_orders_is_applied_from_reverse_relation_on_m2m():
+    async with database:
+
+        max = await Animal(name="Max", specie="Dog").save()
+        joe = await Human(name="Joe").save()
+        zack = await Human(name="Zack").save()
+        julia = await Human(name="Julia").save()
+
+        await max.care_takers.add(joe)
+        await max.care_takers.add(zack)
+        await max.care_takers.add(julia)
+
+        await max.load_all()
+        assert max.care_takers[0] == joe
+        assert max.care_takers[1] == julia
+        assert max.care_takers[2] == zack

tests/test_default_through_relation_order.py

@@ -0,0 +1,176 @@
+from typing import List
+from uuid import UUID, uuid4
+
+import databases
+import pytest
+import sqlalchemy
+
+import ormar
+from tests.settings import DATABASE_URL
+
+database = databases.Database(DATABASE_URL)
+metadata = sqlalchemy.MetaData()
+
+
+class BaseMeta(ormar.ModelMeta):
+    metadata = metadata
+    database = database
+
+
+class Animal(ormar.Model):
+    class Meta(BaseMeta):
+        tablename = "animals"
+
+    id: UUID = ormar.UUID(primary_key=True, default=uuid4)
+    name: str = ormar.Text(default="")
+    # favoriteHumans
+
+
+class Link(ormar.Model):
+    class Meta(BaseMeta):
+        tablename = "link_table"
+
+    id: int = ormar.Integer(primary_key=True)
+    animal_order: int = ormar.Integer(nullable=True)
+    human_order: int = ormar.Integer(nullable=True)
+
+
+class Human(ormar.Model):
+    class Meta(BaseMeta):
+        tablename = "humans"
+
+    id: UUID = ormar.UUID(primary_key=True, default=uuid4)
+    name: str = ormar.Text(default="")
+    favoriteAnimals: List[Animal] = ormar.ManyToMany(
+        Animal,
+        through=Link,
+        related_name="favoriteHumans",
+        orders_by=["link__animal_order"],
+        related_orders_by=["link__human_order"],
+    )
+
+
+@pytest.fixture(autouse=True, scope="module")
+def create_test_database():
+    engine = sqlalchemy.create_engine(DATABASE_URL)
+    metadata.drop_all(engine)
+    metadata.create_all(engine)
+    yield
+    metadata.drop_all(engine)
+
+
+@pytest.mark.asyncio
+async def test_ordering_by_through_on_m2m_field():
+    async with database:
+        alice = await Human(name="Alice").save()
+        bob = await Human(name="Bob").save()
+        charlie = await Human(name="Charlie").save()
+
+        spot = await Animal(name="Spot").save()
+        kitty = await Animal(name="Kitty").save()
+        noodle = await Animal(name="Noodle").save()
+
+        # you need to add them in order anyway so can provide order explicitly
+        # if you have a lot of them a list with enumerate might be an option
+        await alice.favoriteAnimals.add(noodle, animal_order=0, human_order=0)
+        await alice.favoriteAnimals.add(spot, animal_order=1, human_order=0)
+        await alice.favoriteAnimals.add(kitty, animal_order=2, human_order=0)
+
+        # you dont have to reload queries on queryset clears the existing related
+        # alice = await alice.reload()
+        await alice.load_all()
+        assert [x.name for x in alice.favoriteAnimals] == ["Noodle", "Spot", "Kitty"]
+
+        await bob.favoriteAnimals.add(noodle, animal_order=0, human_order=1)
+        await bob.favoriteAnimals.add(kitty, animal_order=1, human_order=1)
+        await bob.favoriteAnimals.add(spot, animal_order=2, human_order=1)
+
+        await bob.load_all()
+        assert [x.name for x in bob.favoriteAnimals] == ["Noodle", "Kitty", "Spot"]
+
+        await charlie.favoriteAnimals.add(kitty, animal_order=0, human_order=2)
+        await charlie.favoriteAnimals.add(noodle, animal_order=1, human_order=2)
+        await charlie.favoriteAnimals.add(spot, animal_order=2, human_order=2)
+
+        await charlie.load_all()
+        assert [x.name for x in charlie.favoriteAnimals] == ["Kitty", "Noodle", "Spot"]
+
+        animals = [noodle, kitty, spot]
+        for animal in animals:
+            await animal.load_all()
+            assert [x.name for x in animal.favoriteHumans] == [
+                "Alice",
+                "Bob",
+                "Charlie",
+            ]
+
+        zack = await Human(name="Zack").save()
+
+        async def reorder_humans(animal, new_ordered_humans):
+            noodle_links = await Link.objects.filter(animal=animal).all()
+            for link in noodle_links:
+                link.human_order = next(
+                    (
+                        i
+                        for i, x in enumerate(new_ordered_humans)
+                        if x.pk == link.human.pk
+                    ),
+                    None,
+                )
+            await Link.objects.bulk_update(noodle_links, columns=["human_order"])
+
+        await noodle.favoriteHumans.add(zack, animal_order=0, human_order=0)
+        await reorder_humans(noodle, [zack, alice, bob, charlie])
+        await noodle.load_all()
+        assert [x.name for x in noodle.favoriteHumans] == [
+            "Zack",
+            "Alice",
+            "Bob",
+            "Charlie",
+        ]
+
+        await zack.load_all()
+        assert [x.name for x in zack.favoriteAnimals] == ["Noodle"]
+
+        humans = noodle.favoriteHumans
+        humans.insert(1, humans.pop(0))
+        await reorder_humans(noodle, humans)
+        await noodle.load_all()
+        assert [x.name for x in noodle.favoriteHumans] == [
+            "Alice",
+            "Zack",
+            "Bob",
+            "Charlie",
+        ]
+
+        humans.insert(2, humans.pop(1))
+        await reorder_humans(noodle, humans)
+        await noodle.load_all()
+        assert [x.name for x in noodle.favoriteHumans] == [
+            "Alice",
+            "Bob",
+            "Zack",
+            "Charlie",
+        ]
+
+        humans.insert(3, humans.pop(2))
+        await reorder_humans(noodle, humans)
+        await noodle.load_all()
+        assert [x.name for x in noodle.favoriteHumans] == [
+            "Alice",
+            "Bob",
+            "Charlie",
+            "Zack",
+        ]
+
+        await kitty.favoriteHumans.remove(bob)
+        await kitty.load_all()
+        assert [x.name for x in kitty.favoriteHumans] == ["Alice", "Charlie"]
+
+        bob = await noodle.favoriteHumans.get(pk=bob.pk)
+        assert bob.link.human_order == 1
+        await noodle.favoriteHumans.remove(
+            await noodle.favoriteHumans.filter(link__human_order=2).get()
+        )
+        await noodle.load_all()
+        assert [x.name for x in noodle.favoriteHumans] == ["Alice", "Bob", "Zack"]

tests/test_load_all.py

@@ -107,6 +107,30 @@ async def test_load_all_many_to_many():
             assert hq.nicks[1].name == "Bazinga20"
 
 
+@pytest.mark.asyncio
+async def test_load_all_with_order():
+    async with database:
+        async with database.transaction(force_rollback=True):
+            nick1 = await NickName.objects.create(name="Barry", is_lame=False)
+            nick2 = await NickName.objects.create(name="Joe", is_lame=True)
+            hq = await HQ.objects.create(name="Main")
+            await hq.nicks.add(nick1)
+            await hq.nicks.add(nick2)
+
+            hq = await HQ.objects.get(name="Main")
+            await hq.load_all(order_by="-nicks__name")
+
+            assert hq.nicks[0] == nick2
+            assert hq.nicks[0].name == "Joe"
+
+            assert hq.nicks[1] == nick1
+            assert hq.nicks[1].name == "Barry"
+
+            await hq.load_all()
+            assert hq.nicks[0] == nick1
+            assert hq.nicks[1] == nick2
+
+
 @pytest.mark.asyncio
 async def test_loading_reversed_relation():
     async with database:

tests/test_proper_order_of_sorting_apply.py

@@ -0,0 +1,78 @@
+from typing import Optional
+
+import databases
+import pytest
+import sqlalchemy
+
+import ormar
+from tests.settings import DATABASE_URL
+
+database = databases.Database(DATABASE_URL)
+metadata = sqlalchemy.MetaData()
+
+
+class BaseMeta(ormar.ModelMeta):
+    metadata = metadata
+    database = database
+
+
+class Author(ormar.Model):
+    class Meta(BaseMeta):
+        tablename = "authors"
+
+    id: int = ormar.Integer(primary_key=True)
+    name: str = ormar.String(max_length=100)
+
+
+class Book(ormar.Model):
+    class Meta(BaseMeta):
+        tablename = "books"
+        order_by = ["-ranking"]
+
+    id: int = ormar.Integer(primary_key=True)
+    author: Optional[Author] = ormar.ForeignKey(
+        Author, orders_by=["name"], related_orders_by=["-year"]
+    )
+    title: str = ormar.String(max_length=100)
+    year: int = ormar.Integer(nullable=True)
+    ranking: int = ormar.Integer(nullable=True)
+
+
+@pytest.fixture(autouse=True, scope="module")
+def create_test_database():
+    engine = sqlalchemy.create_engine(DATABASE_URL)
+    metadata.drop_all(engine)
+    metadata.create_all(engine)
+    yield
+    metadata.drop_all(engine)
+
+
+@pytest.fixture(autouse=True, scope="function")
+async def cleanup():
+    await Book.objects.delete(each=True)
+    await Author.objects.delete(each=True)
+
+
+@pytest.mark.asyncio
+async def test_default_orders_is_applied_from_reverse_relation():
+    async with database:
+        tolkien = await Author(name="J.R.R. Tolkien").save()
+        hobbit = await Book(author=tolkien, title="The Hobbit", year=1933).save()
+        silmarillion = await Book(
+            author=tolkien, title="The Silmarillion", year=1977
+        ).save()
+        lotr = await Book(
+            author=tolkien, title="The Lord of the Rings", year=1955
+        ).save()
+
+        tolkien = await Author.objects.select_related("books").get()
+        assert tolkien.books[2] == hobbit
+        assert tolkien.books[1] == lotr
+        assert tolkien.books[0] == silmarillion
+
+        tolkien = (
+            await Author.objects.select_related("books").order_by("books__title").get()
+        )
+        assert tolkien.books[0] == hobbit
+        assert tolkien.books[1] == lotr
+        assert tolkien.books[2] == silmarillion