Remove CRUD test modules for unused and deprecated features

- Deleted `test_crud_base.py`, `test_crud_error_paths.py`, and `test_organization_async.py` due to the removal of corresponding deprecated CRUD implementations.
- Improved codebase maintainability and reduced test suite noise by eliminating obsolete test files.

backend/tests/crud/test_user.py

@@ -1,125 +1,644 @@
+# tests/crud/test_user_async.py
+"""
+Comprehensive tests for async user CRUD operations.
+"""
 import pytest
+from datetime import datetime, timezone
+from uuid import uuid4
 
 from app.crud.user import user as user_crud
 from app.models.user import User
 from app.schemas.users import UserCreate, UserUpdate
 
 
-def test_create_user(db_session, user_create_data):
-    user_in = UserCreate(**user_create_data)
-    user_obj = user_crud.create(db_session, obj_in=user_in)
+class TestGetByEmail:
+    """Tests for get_by_email method."""
 
-    assert user_obj.email == user_create_data["email"]
-    assert user_obj.first_name == user_create_data["first_name"]
-    assert user_obj.last_name == user_create_data["last_name"]
-    assert user_obj.phone_number == user_create_data["phone_number"]
-    assert user_obj.is_superuser == user_create_data["is_superuser"]
-    assert user_obj.password_hash is not None
-    assert user_obj.id is not None
+    @pytest.mark.asyncio
+    async def test_get_by_email_success(self, async_test_db, async_test_user):
+        """Test getting user by email."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        async with AsyncTestingSessionLocal() as session:
+            result = await user_crud.get_by_email(session, email=async_test_user.email)
+            assert result is not None
+            assert result.email == async_test_user.email
+            assert result.id == async_test_user.id
+
+    @pytest.mark.asyncio
+    async def test_get_by_email_not_found(self, async_test_db):
+        """Test getting non-existent email returns None."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        async with AsyncTestingSessionLocal() as session:
+            result = await user_crud.get_by_email(session, email="nonexistent@example.com")
+            assert result is None
 
 
-def test_get_user(db_session, mock_user):
-    # Using mock_user fixture instead of creating new user
-    stored_user = user_crud.get(db_session, id=mock_user.id)
-    assert stored_user
-    assert stored_user.id == mock_user.id
-    assert stored_user.email == mock_user.email
+class TestCreate:
+    """Tests for create method."""
+
+    @pytest.mark.asyncio
+    async def test_create_user_success(self, async_test_db):
+        """Test successfully creating a user_crud."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        async with AsyncTestingSessionLocal() as session:
+            user_data = UserCreate(
+                email="newuser@example.com",
+                password="SecurePass123!",
+                first_name="New",
+                last_name="User",
+                phone_number="+1234567890"
+            )
+            result = await user_crud.create(session, obj_in=user_data)
+
+            assert result.email == "newuser@example.com"
+            assert result.first_name == "New"
+            assert result.last_name == "User"
+            assert result.phone_number == "+1234567890"
+            assert result.is_active is True
+            assert result.is_superuser is False
+            assert result.password_hash is not None
+            assert result.password_hash != "SecurePass123!"  # Password should be hashed
+
+    @pytest.mark.asyncio
+    async def test_create_superuser_success(self, async_test_db):
+        """Test creating a superuser."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        async with AsyncTestingSessionLocal() as session:
+            user_data = UserCreate(
+                email="superuser@example.com",
+                password="SuperPass123!",
+                first_name="Super",
+                last_name="User",
+                is_superuser=True
+            )
+            result = await user_crud.create(session, obj_in=user_data)
+
+            assert result.is_superuser is True
+            assert result.email == "superuser@example.com"
+
+    @pytest.mark.asyncio
+    async def test_create_duplicate_email_fails(self, async_test_db, async_test_user):
+        """Test creating user with duplicate email raises ValueError."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        async with AsyncTestingSessionLocal() as session:
+            user_data = UserCreate(
+                email=async_test_user.email,  # Duplicate email
+                password="AnotherPass123!",
+                first_name="Duplicate",
+                last_name="User"
+            )
+
+            with pytest.raises(ValueError) as exc_info:
+                await user_crud.create(session, obj_in=user_data)
+
+            assert "already exists" in str(exc_info.value).lower()
 
 
-def test_get_user_by_email(db_session, mock_user):
-    stored_user = user_crud.get_by_email(db_session, email=mock_user.email)
-    assert stored_user
-    assert stored_user.id == mock_user.id
-    assert stored_user.email == mock_user.email
+class TestUpdate:
+    """Tests for update method."""
+
+    @pytest.mark.asyncio
+    async def test_update_user_basic_fields(self, async_test_db, async_test_user):
+        """Test updating basic user fields."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        async with AsyncTestingSessionLocal() as session:
+            # Get fresh copy of user
+            user = await user_crud.get(session, id=str(async_test_user.id))
+
+            update_data = UserUpdate(
+                first_name="Updated",
+                last_name="Name",
+                phone_number="+9876543210"
+            )
+            result = await user_crud.update(session, db_obj=user, obj_in=update_data)
+
+            assert result.first_name == "Updated"
+            assert result.last_name == "Name"
+            assert result.phone_number == "+9876543210"
+
+    @pytest.mark.asyncio
+    async def test_update_user_password(self, async_test_db):
+        """Test updating user password."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        # Create a fresh user for this test
+        async with AsyncTestingSessionLocal() as session:
+            user_data = UserCreate(
+                email="passwordtest@example.com",
+                password="OldPassword123!",
+                first_name="Pass",
+                last_name="Test"
+            )
+            user = await user_crud.create(session, obj_in=user_data)
+            user_id = user.id
+            old_password_hash = user.password_hash
+
+        # Update the password
+        async with AsyncTestingSessionLocal() as session:
+            user = await user_crud.get(session, id=str(user_id))
+
+            update_data = UserUpdate(password="NewDifferentPassword123!")
+            result = await user_crud.update(session, db_obj=user, obj_in=update_data)
+
+            await session.refresh(result)
+            assert result.password_hash != old_password_hash
+            assert result.password_hash is not None
+            assert "NewDifferentPassword123!" not in result.password_hash  # Should be hashed
+
+    @pytest.mark.asyncio
+    async def test_update_user_with_dict(self, async_test_db, async_test_user):
+        """Test updating user with dictionary."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        async with AsyncTestingSessionLocal() as session:
+            user = await user_crud.get(session, id=str(async_test_user.id))
+
+            update_dict = {"first_name": "DictUpdate"}
+            result = await user_crud.update(session, db_obj=user, obj_in=update_dict)
+
+            assert result.first_name == "DictUpdate"
 
 
-def test_update_user(db_session, mock_user):
-    update_data = UserUpdate(
-        first_name="Updated",
-        last_name="Name",
-        phone_number="+9876543210"
-    )
+class TestGetMultiWithTotal:
+    """Tests for get_multi_with_total method."""
 
-    updated_user = user_crud.update(db_session, db_obj=mock_user, obj_in=update_data)
+    @pytest.mark.asyncio
+    async def test_get_multi_with_total_basic(self, async_test_db, async_test_user):
+        """Test basic pagination."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
 
-    assert updated_user.first_name == "Updated"
-    assert updated_user.last_name == "Name"
-    assert updated_user.phone_number == "+9876543210"
-    assert updated_user.email == mock_user.email
+        async with AsyncTestingSessionLocal() as session:
+            users, total = await user_crud.get_multi_with_total(
+                session,
+                skip=0,
+                limit=10
+            )
+            assert total >= 1
+            assert len(users) >= 1
+            assert any(u.id == async_test_user.id for u in users)
+
+    @pytest.mark.asyncio
+    async def test_get_multi_with_total_sorting_asc(self, async_test_db):
+        """Test sorting in ascending order."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        # Create multiple users
+        async with AsyncTestingSessionLocal() as session:
+            for i in range(3):
+                user_data = UserCreate(
+                    email=f"sort{i}@example.com",
+                    password="SecurePass123!",
+                    first_name=f"User{i}",
+                    last_name="Test"
+                )
+                await user_crud.create(session, obj_in=user_data)
+
+        async with AsyncTestingSessionLocal() as session:
+            users, total = await user_crud.get_multi_with_total(
+                session,
+                skip=0,
+                limit=10,
+                sort_by="email",
+                sort_order="asc"
+            )
+
+            # Check if sorted (at least the test users)
+            test_users = [u for u in users if u.email.startswith("sort")]
+            if len(test_users) > 1:
+                assert test_users[0].email < test_users[1].email
+
+    @pytest.mark.asyncio
+    async def test_get_multi_with_total_sorting_desc(self, async_test_db):
+        """Test sorting in descending order."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        # Create multiple users
+        async with AsyncTestingSessionLocal() as session:
+            for i in range(3):
+                user_data = UserCreate(
+                    email=f"desc{i}@example.com",
+                    password="SecurePass123!",
+                    first_name=f"User{i}",
+                    last_name="Test"
+                )
+                await user_crud.create(session, obj_in=user_data)
+
+        async with AsyncTestingSessionLocal() as session:
+            users, total = await user_crud.get_multi_with_total(
+                session,
+                skip=0,
+                limit=10,
+                sort_by="email",
+                sort_order="desc"
+            )
+
+            # Check if sorted descending (at least the test users)
+            test_users = [u for u in users if u.email.startswith("desc")]
+            if len(test_users) > 1:
+                assert test_users[0].email > test_users[1].email
+
+    @pytest.mark.asyncio
+    async def test_get_multi_with_total_filtering(self, async_test_db):
+        """Test filtering by field."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        # Create active and inactive users
+        async with AsyncTestingSessionLocal() as session:
+            active_user = UserCreate(
+                email="active@example.com",
+                password="SecurePass123!",
+                first_name="Active",
+                last_name="User"
+            )
+            await user_crud.create(session, obj_in=active_user)
+
+            inactive_user = UserCreate(
+                email="inactive@example.com",
+                password="SecurePass123!",
+                first_name="Inactive",
+                last_name="User"
+            )
+            created_inactive = await user_crud.create(session, obj_in=inactive_user)
+
+            # Deactivate the user
+            await user_crud.update(
+                session,
+                db_obj=created_inactive,
+                obj_in={"is_active": False}
+            )
+
+        async with AsyncTestingSessionLocal() as session:
+            users, total = await user_crud.get_multi_with_total(
+                session,
+                skip=0,
+                limit=100,
+                filters={"is_active": True}
+            )
+
+            # All returned users should be active
+            assert all(u.is_active for u in users)
+
+    @pytest.mark.asyncio
+    async def test_get_multi_with_total_search(self, async_test_db):
+        """Test search functionality."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        # Create user with unique name
+        async with AsyncTestingSessionLocal() as session:
+            user_data = UserCreate(
+                email="searchable@example.com",
+                password="SecurePass123!",
+                first_name="Searchable",
+                last_name="UserName"
+            )
+            await user_crud.create(session, obj_in=user_data)
+
+        async with AsyncTestingSessionLocal() as session:
+            users, total = await user_crud.get_multi_with_total(
+                session,
+                skip=0,
+                limit=100,
+                search="Searchable"
+            )
+
+            assert total >= 1
+            assert any(u.first_name == "Searchable" for u in users)
+
+    @pytest.mark.asyncio
+    async def test_get_multi_with_total_pagination(self, async_test_db):
+        """Test pagination with skip and limit."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        # Create multiple users
+        async with AsyncTestingSessionLocal() as session:
+            for i in range(5):
+                user_data = UserCreate(
+                    email=f"page{i}@example.com",
+                    password="SecurePass123!",
+                    first_name=f"Page{i}",
+                    last_name="User"
+                )
+                await user_crud.create(session, obj_in=user_data)
+
+        async with AsyncTestingSessionLocal() as session:
+            # Get first page
+            users_page1, total = await user_crud.get_multi_with_total(
+                session,
+                skip=0,
+                limit=2
+            )
+
+            # Get second page
+            users_page2, total2 = await user_crud.get_multi_with_total(
+                session,
+                skip=2,
+                limit=2
+            )
+
+            # Total should be same
+            assert total == total2
+            # Different users on different pages
+            assert users_page1[0].id != users_page2[0].id
+
+    @pytest.mark.asyncio
+    async def test_get_multi_with_total_validation_negative_skip(self, async_test_db):
+        """Test validation fails for negative skip."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        async with AsyncTestingSessionLocal() as session:
+            with pytest.raises(ValueError) as exc_info:
+                await user_crud.get_multi_with_total(session, skip=-1, limit=10)
+
+            assert "skip must be non-negative" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_get_multi_with_total_validation_negative_limit(self, async_test_db):
+        """Test validation fails for negative limit."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        async with AsyncTestingSessionLocal() as session:
+            with pytest.raises(ValueError) as exc_info:
+                await user_crud.get_multi_with_total(session, skip=0, limit=-1)
+
+            assert "limit must be non-negative" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_get_multi_with_total_validation_max_limit(self, async_test_db):
+        """Test validation fails for limit > 1000."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        async with AsyncTestingSessionLocal() as session:
+            with pytest.raises(ValueError) as exc_info:
+                await user_crud.get_multi_with_total(session, skip=0, limit=1001)
+
+            assert "Maximum limit is 1000" in str(exc_info.value)
 
 
-def test_delete_user(db_session, mock_user):
-    user_crud.remove(db_session, id=mock_user.id)
-    deleted_user = user_crud.get(db_session, id=mock_user.id)
-    assert deleted_user is None
+class TestBulkUpdateStatus:
+    """Tests for bulk_update_status method."""
+
+    @pytest.mark.asyncio
+    async def test_bulk_update_status_success(self, async_test_db):
+        """Test bulk updating user status."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        # Create multiple users
+        user_ids = []
+        async with AsyncTestingSessionLocal() as session:
+            for i in range(3):
+                user_data = UserCreate(
+                    email=f"bulk{i}@example.com",
+                    password="SecurePass123!",
+                    first_name=f"Bulk{i}",
+                    last_name="User"
+                )
+                user = await user_crud.create(session, obj_in=user_data)
+                user_ids.append(user.id)
+
+        # Bulk deactivate
+        async with AsyncTestingSessionLocal() as session:
+            count = await user_crud.bulk_update_status(
+                session,
+                user_ids=user_ids,
+                is_active=False
+            )
+            assert count == 3
+
+        # Verify all are inactive
+        async with AsyncTestingSessionLocal() as session:
+            for user_id in user_ids:
+                user = await user_crud.get(session, id=str(user_id))
+                assert user.is_active is False
+
+    @pytest.mark.asyncio
+    async def test_bulk_update_status_empty_list(self, async_test_db):
+        """Test bulk update with empty list returns 0."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        async with AsyncTestingSessionLocal() as session:
+            count = await user_crud.bulk_update_status(
+                session,
+                user_ids=[],
+                is_active=False
+            )
+            assert count == 0
+
+    @pytest.mark.asyncio
+    async def test_bulk_update_status_reactivate(self, async_test_db):
+        """Test bulk reactivating users."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        # Create inactive user
+        async with AsyncTestingSessionLocal() as session:
+            user_data = UserCreate(
+                email="reactivate@example.com",
+                password="SecurePass123!",
+                first_name="Reactivate",
+                last_name="User"
+            )
+            user = await user_crud.create(session, obj_in=user_data)
+            # Deactivate
+            await user_crud.update(session, db_obj=user, obj_in={"is_active": False})
+            user_id = user.id
+
+        # Reactivate
+        async with AsyncTestingSessionLocal() as session:
+            count = await user_crud.bulk_update_status(
+                session,
+                user_ids=[user_id],
+                is_active=True
+            )
+            assert count == 1
+
+        # Verify active
+        async with AsyncTestingSessionLocal() as session:
+            user = await user_crud.get(session, id=str(user_id))
+            assert user.is_active is True
 
 
-def test_get_multi_users(db_session, mock_user, user_create_data):
-    # Create additional users (mock_user is already in db)
-    users_data = [
-        {**user_create_data, "email": f"test{i}@example.com"}
-        for i in range(2)  # Creating 2 more users + mock_user = 3 total
-    ]
+class TestBulkSoftDelete:
+    """Tests for bulk_soft_delete method."""
 
-    for user_data in users_data:
-        user_in = UserCreate(**user_data)
-        user_crud.create(db_session, obj_in=user_in)
+    @pytest.mark.asyncio
+    async def test_bulk_soft_delete_success(self, async_test_db):
+        """Test bulk soft deleting users."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
 
-    users = user_crud.get_multi(db_session, skip=0, limit=10)
-    assert len(users) == 3
-    assert all(isinstance(user, User) for user in users)
+        # Create multiple users
+        user_ids = []
+        async with AsyncTestingSessionLocal() as session:
+            for i in range(3):
+                user_data = UserCreate(
+                    email=f"delete{i}@example.com",
+                    password="SecurePass123!",
+                    first_name=f"Delete{i}",
+                    last_name="User"
+                )
+                user = await user_crud.create(session, obj_in=user_data)
+                user_ids.append(user.id)
+
+        # Bulk delete
+        async with AsyncTestingSessionLocal() as session:
+            count = await user_crud.bulk_soft_delete(
+                session,
+                user_ids=user_ids
+            )
+            assert count == 3
+
+        # Verify all are soft deleted
+        async with AsyncTestingSessionLocal() as session:
+            for user_id in user_ids:
+                user = await user_crud.get(session, id=str(user_id))
+                assert user.deleted_at is not None
+                assert user.is_active is False
+
+    @pytest.mark.asyncio
+    async def test_bulk_soft_delete_with_exclusion(self, async_test_db):
+        """Test bulk soft delete with excluded user_crud."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        # Create multiple users
+        user_ids = []
+        async with AsyncTestingSessionLocal() as session:
+            for i in range(3):
+                user_data = UserCreate(
+                    email=f"exclude{i}@example.com",
+                    password="SecurePass123!",
+                    first_name=f"Exclude{i}",
+                    last_name="User"
+                )
+                user = await user_crud.create(session, obj_in=user_data)
+                user_ids.append(user.id)
+
+        # Bulk delete, excluding first user
+        exclude_id = user_ids[0]
+        async with AsyncTestingSessionLocal() as session:
+            count = await user_crud.bulk_soft_delete(
+                session,
+                user_ids=user_ids,
+                exclude_user_id=exclude_id
+            )
+            assert count == 2  # Only 2 deleted
+
+        # Verify excluded user is NOT deleted
+        async with AsyncTestingSessionLocal() as session:
+            excluded_user = await user_crud.get(session, id=str(exclude_id))
+            assert excluded_user.deleted_at is None
+
+    @pytest.mark.asyncio
+    async def test_bulk_soft_delete_empty_list(self, async_test_db):
+        """Test bulk delete with empty list returns 0."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        async with AsyncTestingSessionLocal() as session:
+            count = await user_crud.bulk_soft_delete(
+                session,
+                user_ids=[]
+            )
+            assert count == 0
+
+    @pytest.mark.asyncio
+    async def test_bulk_soft_delete_all_excluded(self, async_test_db):
+        """Test bulk delete where all users are excluded."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        # Create user
+        async with AsyncTestingSessionLocal() as session:
+            user_data = UserCreate(
+                email="onlyuser@example.com",
+                password="SecurePass123!",
+                first_name="Only",
+                last_name="User"
+            )
+            user = await user_crud.create(session, obj_in=user_data)
+            user_id = user.id
+
+        # Try to delete but exclude
+        async with AsyncTestingSessionLocal() as session:
+            count = await user_crud.bulk_soft_delete(
+                session,
+                user_ids=[user_id],
+                exclude_user_id=user_id
+            )
+            assert count == 0
+
+    @pytest.mark.asyncio
+    async def test_bulk_soft_delete_already_deleted(self, async_test_db):
+        """Test bulk delete doesn't re-delete already deleted users."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
+
+        # Create and delete user
+        async with AsyncTestingSessionLocal() as session:
+            user_data = UserCreate(
+                email="predeleted@example.com",
+                password="SecurePass123!",
+                first_name="PreDeleted",
+                last_name="User"
+            )
+            user = await user_crud.create(session, obj_in=user_data)
+            user_id = user.id
+
+            # First deletion
+            await user_crud.bulk_soft_delete(session, user_ids=[user_id])
+
+        # Try to delete again
+        async with AsyncTestingSessionLocal() as session:
+            count = await user_crud.bulk_soft_delete(
+                session,
+                user_ids=[user_id]
+            )
+            assert count == 0  # Already deleted
 
 
-def test_is_active(db_session, mock_user):
-    assert user_crud.is_active(mock_user) is True
+class TestUtilityMethods:
+    """Tests for utility methods."""
 
-    # Test deactivating user
-    update_data = UserUpdate(is_active=False)
-    deactivated_user = user_crud.update(db_session, db_obj=mock_user, obj_in=update_data)
-    assert user_crud.is_active(deactivated_user) is False
+    @pytest.mark.asyncio
+    async def test_is_active_true(self, async_test_db, async_test_user):
+        """Test is_active returns True for active user_crud."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
 
+        async with AsyncTestingSessionLocal() as session:
+            user = await user_crud.get(session, id=str(async_test_user.id))
+            assert user_crud.is_active(user) is True
 
-def test_is_superuser(db_session, mock_user, user_create_data):
-    # mock_user is regular user
-    assert user_crud.is_superuser(mock_user) is False
+    @pytest.mark.asyncio
+    async def test_is_active_false(self, async_test_db):
+        """Test is_active returns False for inactive user_crud."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
 
-    # Create superuser
-    super_user_data = {**user_create_data, "email": "super@example.com", "is_superuser": True}
-    super_user_in = UserCreate(**super_user_data)
-    super_user = user_crud.create(db_session, obj_in=super_user_in)
-    assert user_crud.is_superuser(super_user) is True
+        async with AsyncTestingSessionLocal() as session:
+            user_data = UserCreate(
+                email="inactive2@example.com",
+                password="SecurePass123!",
+                first_name="Inactive",
+                last_name="User"
+            )
+            user = await user_crud.create(session, obj_in=user_data)
+            await user_crud.update(session, db_obj=user, obj_in={"is_active": False})
 
+            assert user_crud.is_active(user) is False
 
-# Additional test cases
-def test_create_duplicate_email(db_session, mock_user):
-    user_data = UserCreate(
-        email=mock_user.email,  # Try to create user with existing email
-        password="TestPassword123!",
-        first_name="Test",
-        last_name="User"
-    )
-    with pytest.raises(Exception):  # Should raise an integrity error
-        user_crud.create(db_session, obj_in=user_data)
+    @pytest.mark.asyncio
+    async def test_is_superuser_true(self, async_test_db, async_test_superuser):
+        """Test is_superuser returns True for superuser."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
 
+        async with AsyncTestingSessionLocal() as session:
+            user = await user_crud.get(session, id=str(async_test_superuser.id))
+            assert user_crud.is_superuser(user) is True
 
-def test_update_user_preferences(db_session, mock_user):
-    preferences = {"theme": "dark", "notifications": True}
-    update_data = UserUpdate(preferences=preferences)
+    @pytest.mark.asyncio
+    async def test_is_superuser_false(self, async_test_db, async_test_user):
+        """Test is_superuser returns False for regular user_crud."""
+        test_engine, AsyncTestingSessionLocal = async_test_db
 
-    updated_user = user_crud.update(db_session, db_obj=mock_user, obj_in=update_data)
-    assert updated_user.preferences == preferences
-
-
-def test_get_multi_users_pagination(db_session, user_create_data):
-    # Create 5 users
-    for i in range(5):
-        user_in = UserCreate(**{**user_create_data, "email": f"test{i}@example.com"})
-        user_crud.create(db_session, obj_in=user_in)
-
-    # Test pagination
-    first_page = user_crud.get_multi(db_session, skip=0, limit=2)
-    second_page = user_crud.get_multi(db_session, skip=2, limit=2)
-
-    assert len(first_page) == 2
-    assert len(second_page) == 2
-    assert first_page[0].id != second_page[0].id
+        async with AsyncTestingSessionLocal() as session:
+            user = await user_crud.get(session, id=str(async_test_user.id))
+            assert user_crud.is_superuser(user) is False