fastapi-repository 0.0.1__tar.gz

fastapi_repository-0.0.1/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: fastapi-repository
+Version: 0.0.1
+Summary: A base repository for FastAPI projects, inspired by Ruby on Rails' Active Record and Ransack.
+Author-email: Seiya Takeda <takedaseiya@gmail.com>
+Project-URL: Homepage, https://github.com/seiyat/fastapi-repository
+Project-URL: Bug Tracker, https://github.com/seiyat/fastapi-repository/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: sqlalchemy>=1.4.0
+Requires-Dist: fastapi>=0.70.0
+
+# FastAPI Repository
+
+A base repository for FastAPI projects, inspired by Ruby on Rails' Active Record and Ransack.
+
+## Installation
+
+```bash
+pip install fastapi-repository
+```
+
+## Usage
+
+```python
+from fastapi_repository import BaseRepository
+from sqlalchemy.ext.asyncio import AsyncSession
+from .models import User
+
+class UserRepository(BaseRepository):
+    def __init__(self, session: AsyncSession):
+        super().__init__(session, model=User)
+```

fastapi_repository-0.0.1/README.md

@@ -0,0 +1,21 @@
+# FastAPI Repository
+
+A base repository for FastAPI projects, inspired by Ruby on Rails' Active Record and Ransack.
+
+## Installation
+
+```bash
+pip install fastapi-repository
+```
+
+## Usage
+
+```python
+from fastapi_repository import BaseRepository
+from sqlalchemy.ext.asyncio import AsyncSession
+from .models import User
+
+class UserRepository(BaseRepository):
+    def __init__(self, session: AsyncSession):
+        super().__init__(session, model=User)
+```

fastapi_repository-0.0.1/fastapi_repository/__init__.py

@@ -0,0 +1,3 @@
+from .base import BaseRepository, OPERATORS
+
+__all__ = ["BaseRepository", "OPERATORS"]

fastapi_repository-0.0.1/fastapi_repository/base.py

@@ -0,0 +1,341 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.exc import NoResultFound
+from sqlalchemy.future import select
+from uuid import UUID
+from sqlalchemy.orm import joinedload, lazyload
+from sqlalchemy import func, update, delete
+from typing import Optional, List, Union, Dict, Any
+
+OPERATORS = {
+    # 完全一致
+    "exact": lambda col, val: col == val,
+    "iexact": lambda col, val: col.ilike(val),
+    # 部分一致
+    "contains": lambda col, val: col.contains(val),
+    "icontains": lambda col, val: col.ilike(f"%{val}%"),
+    # in句
+    "in": lambda col, val: col.in_(val) if isinstance(val, list) else col.in_([val]),
+    # 大小比較
+    "gt": lambda col, val: col > val,
+    "gte": lambda col, val: col >= val,
+    "lt": lambda col, val: col < val,
+    "lte": lambda col, val: col <= val,
+    # 前方・後方一致
+    "startswith": lambda col, val: col.startswith(val),
+    "istartswith": lambda col, val: col.ilike(f"{val}%"),
+    "endswith": lambda col, val: col.endswith(val),
+    "iendswith": lambda col, val: col.ilike(f"%{val}"),
+}
+
+
+class BaseRepository:
+    default_scope: dict = {}
+
+    def __init__(self, session: AsyncSession, model=None):
+        self.session = session
+        if not model:
+            raise ValueError("Model is not set for this repository.")
+        self.model = model
+
+    async def find(
+        self,
+        id: Union[int, UUID],
+        sorted_by: Optional[str] = None,
+        sorted_order: str = "asc",
+        joinedload_models: Optional[List] = None,
+        lazyload_models: Optional[List] = None,
+        disable_default_scope: bool = False,
+    ):
+        """
+        Find a record by its ID. Raise an exception if not found.
+        """
+        query = await self.__generate_query(
+            limit=1,
+            offset=0,
+            sorted_by=sorted_by,
+            sorted_order=sorted_order,
+            joinedload_models=joinedload_models,
+            lazyload_models=lazyload_models,
+            disable_default_scope=disable_default_scope,
+            id=id,
+        )
+
+        result = await self.session.execute(query)
+        instance = result.scalars().first()
+
+        if not instance:
+            raise NoResultFound(f"{self.model.__name__} with id {id} not found.")
+
+        return instance
+
+    async def find_by(
+        self,
+        sorted_by: Optional[str] = None,
+        sorted_order: str = "asc",
+        joinedload_models: Optional[List] = None,
+        lazyload_models: Optional[List] = None,
+        disable_default_scope: bool = False,
+        **search_params,
+    ):
+        """
+        Find a record by given attributes. Return None if not found.
+        """
+        query = await self.__generate_query(
+            limit=1,
+            offset=0,
+            sorted_by=sorted_by,
+            sorted_order=sorted_order,
+            joinedload_models=joinedload_models,
+            lazyload_models=lazyload_models,
+            disable_default_scope=disable_default_scope,
+            **search_params,
+        )
+        result = await self.session.execute(query)
+        instance = result.scalars().first()
+        return instance
+
+    async def find_by_or_raise(
+        self,
+        sorted_by: Optional[str] = None,
+        sorted_order: str = "asc",
+        joinedload_models: Optional[List] = None,
+        lazyload_models: Optional[List] = None,
+        disable_default_scope: bool = False,
+        **search_params,
+    ):
+        """
+        Find a record by given attributes. Raise an exception if not found.
+        """
+        instance = await self.find_by(
+            sorted_by=sorted_by,
+            sorted_order=sorted_order,
+            joinedload_models=joinedload_models,
+            lazyload_models=lazyload_models,
+            disable_default_scope=disable_default_scope,
+            **search_params,
+        )
+        if not instance:
+            raise NoResultFound(
+                f"{self.model.__name__} with attributes {search_params} not found."
+            )
+        return instance
+
+    async def where(
+        self,
+        limit: int = 100,
+        offset: int = 0,
+        sorted_by: Optional[str] = None,
+        sorted_order: str = "asc",
+        joinedload_models: Optional[List] = None,
+        lazyload_models: Optional[List] = None,
+        disable_default_scope: bool = False,
+        **search_params,
+    ):
+        """
+        Find records with optional filtering, sorting, and pagination.
+        """
+        query = await self.__generate_query(
+            limit=limit,
+            offset=offset,
+            sorted_by=sorted_by,
+            sorted_order=sorted_order,
+            joinedload_models=joinedload_models,
+            lazyload_models=lazyload_models,
+            disable_default_scope=disable_default_scope,
+            **search_params,
+        )
+        result = await self.session.execute(query)
+        return result.unique().scalars().all()
+
+    async def count(self, disable_default_scope: bool = False, **search_params) -> int:
+        """
+        Count records with optional filtering.
+        """
+        conditions = []
+        if not disable_default_scope:
+            default_conditions = await self.__get_conditions(**self.default_scope)
+            conditions.extend(default_conditions)
+
+        conditions += await self.__get_conditions(**search_params)
+        query = select(func.count("*")).select_from(self.model).where(*conditions)
+        result = await self.session.execute(query)
+        return result.scalar() or 0
+
+    async def exists(
+        self, disable_default_scope: bool = False, **search_params
+    ) -> bool:
+        """
+        Check if any record exists with the given attributes.
+        """
+        counted = await self.count(
+            disable_default_scope=disable_default_scope, **search_params
+        )
+        return counted > 0
+
+    async def __generate_query(
+        self,
+        limit: int = 100,
+        offset: int = 0,
+        sorted_by: Optional[str] = None,
+        sorted_order: str = "asc",
+        joinedload_models: Optional[List] = None,
+        lazyload_models: Optional[List] = None,
+        disable_default_scope: bool = False,
+        **search_params,
+    ):
+        """
+        Generate a query with optional filtering, sorting, and pagination.
+        Apply default scope if not disabled.
+        """
+        conditions = []
+        if not disable_default_scope:
+            default_conditions = await self.__get_conditions(**self.default_scope)
+            conditions.extend(default_conditions)
+
+        conditions += await self.__get_conditions(**search_params)
+
+        query = select(self.model).where(*conditions)
+
+        if joinedload_models:
+            for model in joinedload_models:
+                query = query.options(joinedload(model))
+        if lazyload_models:
+            for model in lazyload_models:
+                query = query.options(lazyload(model))
+
+        if sorted_by:
+            query = self._apply_order_by(query, sorted_by, sorted_order)
+
+        return query.limit(limit).offset(offset)
+
+    def _apply_order_by(self, query, sorted_by: str, sorted_order: str):
+        """
+        クエリに対して order_by を適用するヘルパー。
+        """
+        column = getattr(self.model, sorted_by, None)
+        if not column:
+            raise AttributeError(
+                f"{self.model.__name__} has no attribute '{sorted_by}'"
+            )
+
+        if sorted_order.lower() == "asc":
+            query = query.order_by(column.asc())
+        else:
+            query = query.order_by(column.desc())
+        return query
+
+    async def __get_conditions(self, **search_params):
+        """
+        Generate conditions for filtering based on provided keyword arguments.
+        Supports Ransack-like operators (field__operator=value).
+        """
+        conditions = []
+        for key, value in search_params.items():
+            # keyに "__" が含まれていれば、フィールド名と演算子を分割する
+            if "__" in key:
+                parts = key.split("__")
+                op = "exact"
+                if parts[-1] in OPERATORS:  # 末尾が演算子なら取り除く
+                    op = parts.pop()
+
+                # 単純カラム: foo__icontains=bar
+                if len(parts) == 1:
+                    column = getattr(self.model, parts[0], None)
+                    if column is None:
+                        raise AttributeError(
+                            f"{self.model.__name__} has no attribute '{parts[0]}'"
+                        )
+                    conditions.append(OPERATORS[op](column, value))
+                    continue
+
+                # 1ホップのリレーション: rel__field__op=value
+                rel_attr = getattr(self.model, parts[0], None)
+                if rel_attr is None or not hasattr(rel_attr, "property"):
+                    raise AttributeError(
+                        f"{self.model.__name__} has no relationship '{parts[0]}'"
+                    )
+                target_cls = rel_attr.property.mapper.class_
+                target_column = getattr(target_cls, parts[1], None)
+                if target_column is None:
+                    raise AttributeError(
+                        f"{target_cls.__name__} has no attribute '{parts[1]}'"
+                    )
+                conditions.append(rel_attr.any(OPERATORS[op](target_column, value)))
+                continue
+            else:
+                # "__"が含まれていない場合は eq (=) 比較とみなす
+                column = getattr(self.model, key, None)
+                if column is None:
+                    raise AttributeError(
+                        f"{self.model.__name__} has no attribute '{key}'"
+                    )
+                conditions.append(column == value)
+
+        return conditions
+
+    async def create(self, **create_params):
+        """
+        Generic create method that instantiates the model,
+        saves it, and returns the new instance.
+        """
+        instance = self.model(**create_params)
+        self.session.add(instance)
+        await self.session.commit()
+        await self.session.refresh(instance)
+        return instance
+
+    async def update(self, id: Union[int, UUID], **update_params):
+        """
+        Update a single record by its primary key.
+        Raises NoResultFound if the record doesn't exist.
+
+        Usage:
+            await repository.update(some_id, field1='value1', field2='value2')
+        """
+        instance = await self.find(id)
+        for field, value in update_params.items():
+            setattr(instance, field, value)
+        await self.session.commit()
+        await self.session.refresh(instance)
+        return instance
+
+    async def update_all(self, updates: Dict[str, Any], **search_params) -> int:
+        """
+        Update all records that match the given conditions in one query.
+        Returns the number of rows that were updated.
+
+        Usage:
+            await repository.update_all(
+                {"field1": "new_value", "field2": 123},
+                some_field__gte=10,
+                other_field="foo"
+            )
+        """
+        conditions = await self.__get_conditions(**search_params)
+        stmt = update(self.model).where(*conditions).values(**updates)
+        result = await self.session.execute(stmt)
+        await self.session.commit()
+        return result.rowcount
+
+    async def destroy(self, id: Union[int, UUID]) -> None:
+        """
+        Destroy (delete) a single record by its primary key.
+        Raises NoResultFound if the record doesn't exist.
+        """
+        instance = await self.find(id)  # Will raise NoResultFound if not found
+        await self.session.delete(instance)
+        await self.session.commit()
+
+    async def destroy_all(self, **search_params) -> int:
+        """
+        Destroy (delete) all records that match the given conditions in one query.
+        Returns the number of rows that were deleted.
+
+        Usage:
+            await repository.destroy_all(field1="value1", field2__gte=10)
+        """
+        conditions = await self.__get_conditions(**search_params)
+        stmt = delete(self.model).where(*conditions)
+        result = await self.session.execute(stmt)
+        await self.session.commit()
+        return result.rowcount

fastapi_repository-0.0.1/fastapi_repository.egg-info/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: fastapi-repository
+Version: 0.0.1
+Summary: A base repository for FastAPI projects, inspired by Ruby on Rails' Active Record and Ransack.
+Author-email: Seiya Takeda <takedaseiya@gmail.com>
+Project-URL: Homepage, https://github.com/seiyat/fastapi-repository
+Project-URL: Bug Tracker, https://github.com/seiyat/fastapi-repository/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: sqlalchemy>=1.4.0
+Requires-Dist: fastapi>=0.70.0
+
+# FastAPI Repository
+
+A base repository for FastAPI projects, inspired by Ruby on Rails' Active Record and Ransack.
+
+## Installation
+
+```bash
+pip install fastapi-repository
+```
+
+## Usage
+
+```python
+from fastapi_repository import BaseRepository
+from sqlalchemy.ext.asyncio import AsyncSession
+from .models import User
+
+class UserRepository(BaseRepository):
+    def __init__(self, session: AsyncSession):
+        super().__init__(session, model=User)
+```

fastapi_repository-0.0.1/fastapi_repository.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+fastapi_repository/__init__.py
+fastapi_repository/base.py
+fastapi_repository.egg-info/PKG-INFO
+fastapi_repository.egg-info/SOURCES.txt
+fastapi_repository.egg-info/dependency_links.txt
+fastapi_repository.egg-info/requires.txt
+fastapi_repository.egg-info/top_level.txt
+tests/test_base_repository.py

fastapi_repository-0.0.1/fastapi_repository.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fastapi_repository-0.0.1/fastapi_repository.egg-info/requires.txt

@@ -0,0 +1,2 @@
+sqlalchemy>=1.4.0
+fastapi>=0.70.0

fastapi_repository-0.0.1/fastapi_repository.egg-info/top_level.txt

@@ -0,0 +1 @@
+fastapi_repository

fastapi_repository-0.0.1/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fastapi-repository"
+version = "0.0.1"
+authors = [
+  { name="Seiya Takeda", email="takedaseiya@gmail.com" },
+]
+description = "A base repository for FastAPI projects, inspired by Ruby on Rails' Active Record and Ransack."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "sqlalchemy>=1.4.0",
+    "fastapi>=0.70.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/seiyat/fastapi-repository"
+"Bug Tracker" = "https://github.com/seiyat/fastapi-repository/issues"

fastapi_repository-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fastapi_repository-0.0.1/tests/test_base_repository.py

@@ -0,0 +1,336 @@
+from sqlalchemy.exc import NoResultFound
+import pytest
+from uuid import uuid4
+from faker import Faker
+
+fake = Faker()
+
+@pytest.mark.asyncio
+async def test_find_user_by_id(user_repository, user):
+    found_user = await user_repository.find(user.id)
+    assert found_user is not None
+    assert found_user.id == user.id
+
+
+@pytest.mark.asyncio
+async def test_find_user_not_found(user_repository):
+    with pytest.raises(NoResultFound):
+        await user_repository.find(uuid4())
+
+
+@pytest.mark.asyncio
+async def test_count_users(user_repository, users, user):
+    count = await user_repository.count()
+    assert count == len(users) + 1
+
+
+@pytest.mark.asyncio
+async def test_count_users_with_filter(user_repository, users):
+    count = await user_repository.count(email=users[0].email)
+    assert count == 1
+
+
+@pytest.mark.asyncio
+async def test_count_users_with_non_existent_filter(user_repository):
+    count = await user_repository.count(email="non_existent_email@example.com")
+    assert count == 0
+
+
+@pytest.mark.asyncio
+async def test_exists_user(user_repository, user):
+    exists = await user_repository.exists(email=user.email)
+    assert exists is True
+
+
+@pytest.mark.asyncio
+async def test_exists_user_not_found(user_repository):
+    exists = await user_repository.exists(email=fake.email())
+    assert exists is False
+
+
+@pytest.mark.asyncio
+async def test_find_by_or_raise_user(user_repository, user):
+    found_user = await user_repository.find_by_or_raise(email=user.email)
+    assert found_user is not None
+    assert found_user.id == user.id
+    assert found_user.email == user.email
+
+
+@pytest.mark.asyncio
+async def test_find_by_or_raise_user_not_found(user_repository):
+    with pytest.raises(NoResultFound):
+        await user_repository.find_by_or_raise(
+            email=fake.email()
+        )
+
+
+@pytest.mark.asyncio
+async def test_find_user_by_email(user_repository, user):
+    found_user = await user_repository.find_by(email=user.email)
+    assert found_user is not None
+    assert found_user.id == user.id
+    assert found_user.email == user.email
+
+
+@pytest.mark.asyncio
+async def test_find_user_by_email_not_found(user_repository):
+    not_found_user = await user_repository.find_by(email=fake.email())
+    assert not_found_user is None
+
+
+@pytest.mark.asyncio
+async def test_where_exact(user_repository, user):
+    found_users = await user_repository.where(email__exact=user.email)
+    assert len(found_users) == 1
+    assert found_users[0].id == user.id
+
+
+@pytest.mark.asyncio
+async def test_where_iexact(user_repository, user):
+    found_users = await user_repository.where(email__iexact=user.email.upper())
+    assert len(found_users) == 1
+    assert found_users[0].id == user.id
+
+
+@pytest.mark.asyncio
+async def test_where_contains(user_repository, user):
+    substring = user.email[:3]
+    found_users = await user_repository.where(email__contains=substring)
+    assert any(u.id == user.id for u in found_users)
+
+
+@pytest.mark.asyncio
+async def test_where_icontains(user_repository, user):
+    substring = user.email[:3].upper()
+    found_users = await user_repository.where(email__icontains=substring)
+    assert any(u.id == user.id for u in found_users)
+
+
+@pytest.mark.asyncio
+async def test_where_in(user_repository, user):
+    fake_email = fake.email()
+    found_users = await user_repository.where(email__in=[user.email, fake_email])
+    assert len(found_users) == 1
+    assert found_users[0].id == user.id
+
+
+@pytest.mark.asyncio
+async def test_where_startswith(user_repository, user):
+    prefix = user.email.split("@")[0][:3]
+    found_users = await user_repository.where(email__startswith=prefix)
+    assert any(u.id == user.id for u in found_users)
+
+
+@pytest.mark.asyncio
+async def test_where_istartswith(user_repository, user):
+    prefix = user.email.split("@")[0][:3].upper()
+    found_users = await user_repository.where(email__istartswith=prefix)
+    assert any(u.id == user.id for u in found_users)
+
+
+@pytest.mark.asyncio
+async def test_where_endswith(user_repository, user):
+    suffix = user.email.split("@")[-1]
+    found_users = await user_repository.where(email__endswith=suffix)
+    assert any(u.id == user.id for u in found_users)
+
+
+@pytest.mark.asyncio
+async def test_where_iendswith(user_repository, user):
+    suffix = user.email.split("@")[-1].upper()
+    found_users = await user_repository.where(email__iendswith=suffix)
+    assert any(u.id == user.id for u in found_users)
+
+
+@pytest.mark.asyncio
+async def test_where_repository(user_repository, user):
+    found_users = await user_repository.where(email=user.email, id=user.id)
+    assert len(found_users) == 1
+    assert found_users[0].id == user.id
+
+
+@pytest.mark.asyncio
+async def test_where_repository_no_results(user_repository):
+    not_found_users = await user_repository.where(email=fake.email())
+    assert not_found_users == []
+
+
+@pytest.mark.asyncio
+async def test_where_repository_limit(user_repository, users):
+    found_users = await user_repository.where(limit=2)
+    assert len(found_users) == 2
+
+
+@pytest.mark.asyncio
+async def test_where_repository_offset(user_repository, users, user):
+    found_users = await user_repository.where(offset=5)
+    assert len(found_users) == len(users) + 1 - 5
+
+
+@pytest.mark.asyncio
+async def test_where_repository_offset_and_limit(user_repository, users):
+    found_users = await user_repository.where(limit=3, offset=2)
+    assert len(found_users) == 3
+
+
+@pytest.mark.asyncio
+async def test_where_repository_sorted(user_repository, users, user):
+    found_users = await user_repository.where(sorted_by="email", sorted_order="asc")
+    assert len(found_users) == len(users) + 1
+    assert found_users == sorted(found_users, key=lambda u: u.email)
+
+
+@pytest.mark.asyncio
+async def test_where_repository_sorted_desc(user_repository, users, user):
+    found_users = await user_repository.where(sorted_by="email", sorted_order="desc")
+    assert len(found_users) == len(users) + 1
+    assert found_users == sorted(found_users, key=lambda u: u.email, reverse=True)
+
+
+@pytest.mark.asyncio
+async def test_where_repository_attribute_error(user_repository):
+    with pytest.raises(AttributeError, match="User has no attribute 'non_existent_column'"):
+        await user_repository.where(non_existent_column="value")
+
+
+@pytest.mark.asyncio
+async def test_where_repository_sorted_attribute_error(user_repository):
+    with pytest.raises(AttributeError, match="User has no attribute 'non_existent_column'"):
+        await user_repository.where(sorted_by="non_existent_column")
+
+@pytest.mark.asyncio
+async def test_create_user(user_repository):
+    user_data = {
+        "email": "test_create@example.com",
+        "hashed_password": "hashed_password_example",
+    }
+    new_user = await user_repository.create(**user_data)
+
+    assert new_user.id is not None
+    assert new_user.email == user_data["email"]
+    assert new_user.hashed_password == user_data["hashed_password"]
+
+    found_user = await user_repository.find(new_user.id)
+    assert found_user is not None
+    assert found_user.id == new_user.id
+
+
+@pytest.mark.asyncio
+async def test_create_user_with_invalid_field(user_repository):
+    user_data = {
+        "email": "test_invalid@example.com",
+        "hashed_password": "hashed_password_example",
+        "non_existent_field": "some_value",
+    }
+    with pytest.raises(TypeError):
+        await user_repository.create(**user_data)
+
+
+@pytest.mark.asyncio
+async def test_destroy_user(user_repository, user):
+    found_user = await user_repository.find(user.id)
+    assert found_user is not None
+
+    await user_repository.destroy(user.id)
+
+    with pytest.raises(NoResultFound):
+        await user_repository.find(user.id)
+
+
+@pytest.mark.asyncio
+async def test_destroy_user_not_found(user_repository):
+    non_existent_id = uuid4()
+    with pytest.raises(NoResultFound):
+        await user_repository.destroy(non_existent_id)
+
+
+@pytest.mark.asyncio
+async def test_destroy_all_no_conditions(user_repository, users, user):
+    count_before = await user_repository.count()
+    assert count_before == len(users) + 1
+
+    deleted_count = await user_repository.destroy_all()
+    assert deleted_count == len(users) + 1
+
+    count_after = await user_repository.count()
+    assert count_after == 0
+
+
+@pytest.mark.asyncio
+async def test_destroy_all_with_conditions(user_repository, users, user):
+    active_users_count = await user_repository.count(is_active=True)
+    assert active_users_count > 0
+
+    deleted_count = await user_repository.destroy_all(is_active=True)
+    assert deleted_count == active_users_count
+
+    remaining_active = await user_repository.count(is_active=True)
+    assert remaining_active == 0
+
+
+@pytest.mark.asyncio
+async def test_destroy_all_no_match(user_repository):
+    deleted_count = await user_repository.destroy_all(
+        email="this_should_not_match_any@example.com"
+    )
+    assert deleted_count == 0
+
+
+@pytest.mark.asyncio
+async def test_update_user(user_repository, user):
+    new_email = "updated_email@example.com"
+    updated_user = await user_repository.update(user.id, email=new_email)
+
+    assert updated_user.id == user.id
+    assert updated_user.email == new_email
+
+    found_user = await user_repository.find(user.id)
+    assert found_user.email == new_email
+
+
+@pytest.mark.asyncio
+async def test_update_user_not_found(user_repository):
+    non_existent_id = uuid4()
+    with pytest.raises(NoResultFound):
+        await user_repository.update(non_existent_id, email="doesnotexist@example.com")
+
+
+@pytest.mark.asyncio
+async def test_update_all_no_conditions(user_repository, users, user):
+    updated_count = await user_repository.update_all({"failed_attempts": 2})
+    assert updated_count == len(users) + 1
+
+    # Confirm all users have the new value
+    for u in await user_repository.where():
+        assert u.failed_attempts == 2
+
+
+@pytest.mark.asyncio
+async def test_update_all_with_conditions(user_repository, users, user):
+    updated_count = await user_repository.update_all(
+        {"failed_attempts": 3}, is_active=True
+    )
+    assert updated_count > 0
+
+    updated_users = await user_repository.where(failed_attempts=3)
+    for u in updated_users:
+        assert u.is_active is True
+
+    # create inactive user
+    user_data = {
+        "email": "inactive@example.com",
+        "hashed_password": "hashed_password_example",
+        "is_active": False
+    }
+    await user_repository.create(**user_data)
+    inactive_users = await user_repository.where(is_active=False)
+    for iu in inactive_users:
+        assert iu.failed_attempts != 3
+
+
+@pytest.mark.asyncio
+async def test_update_all_no_match(user_repository):
+    updated_count = await user_repository.update_all(
+        {"failed_attempts": 4}, failed_attempts=5
+    )
+    assert updated_count == 0