feat: update tests

Author: qorzj

commondao/commondao.py

@@ -197,7 +197,7 @@ def dump_entity_to_row(entity: BaseModel, *, exclude_none: bool) -> RowDict:
     result: dict[str, Any] = {}
     for key, value in data.items():
         if isinstance(value, (dict, list)):
-            result[key] = orjson.dumps(value)
+            result[key] = orjson.dumps(value).decode()
         elif isinstance(value, Enum):
             result[key] = value.value
         else:

tests/e2e/test_crud_operations.py

@@ -1,18 +1,19 @@
 import os
-from typing import Any, Dict, Optional
+from typing import Annotated, Any, AsyncGenerator, Dict, Optional
 
 import pytest
 import pytest_asyncio
 from pydantic import BaseModel
 
-from commondao import Commondao, connect
+from commondao import Commondao, connect, NotFoundError, is_row_dict
+from commondao.annotation import TableId
 
 
 class User(BaseModel):
-    id: Optional[int] = None
+    id: Annotated[Optional[int], TableId('test_users')] = None
     name: str
     email: str
-    age: int
+    age: Optional[int] = None
 
 
 class TestCRUDOperations:
@@ -28,7 +29,7 @@ async def db_config(self) -> Dict[str, Any]:
         }
 
     @pytest_asyncio.fixture
-    async def db(self, db_config: Dict[str, Any]):
+    async def db(self, db_config: Dict[str, Any]) -> AsyncGenerator[Commondao, None]:
         async with connect(**db_config) as db:
             await db.execute_mutation('''
                 CREATE TABLE IF NOT EXISTS test_users (
@@ -45,133 +46,109 @@ async def db(self, db_config: Dict[str, Any]):
     @pytest.mark.asyncio
     async def test_insert(self, db: Commondao) -> None:
         # 测试基本插入
-        affected_rows = await db.insert(
-            'test_users',
-            data={'name': 'Alice', 'email': 'alice@example.com', 'age': 30}
-        )
+        user = User(name='Alice', email='alice@example.com', age=30)
+        affected_rows = await db.insert(user)
         assert affected_rows == 1
         # 验证数据已插入
         result = await db.execute_query("SELECT * FROM test_users WHERE name = 'Alice'")
         assert len(result) == 1
+        assert is_row_dict(result[0])
         assert result[0]['email'] == 'alice@example.com'
         assert result[0]['age'] == 30
 
     @pytest.mark.asyncio
     async def test_insert_ignore(self, db: Commondao) -> None:
         # 首先插入一条记录
-        await db.insert(
-            'test_users',
-            data={'name': 'Bob', 'email': 'bob@example.com', 'age': 25}
-        )
+        user1 = User(name='Bob', email='bob@example.com', age=25)
+        await db.insert(user1)
         # 尝试使用相同的email插入，应该被忽略
-        affected_rows = await db.insert(
-            'test_users',
-            data={'name': 'Bob2', 'email': 'bob@example.com', 'age': 26},
-            ignore=True
-        )
+        user2 = User(name='Bob2', email='bob@example.com', age=26)
+        affected_rows = await db.insert(user2, ignore=True)
         assert affected_rows == 0
         # 验证原始数据未被修改
         result = await db.execute_query("SELECT * FROM test_users WHERE email = 'bob@example.com'")
         assert len(result) == 1
+        assert is_row_dict(result[0])
         assert result[0]['name'] == 'Bob'
         assert result[0]['age'] == 25
 
     @pytest.mark.asyncio
     async def test_insert_with_none_values(self, db: Commondao) -> None:
         # 测试包含None值的插入
-        affected_rows = await db.insert(
-            'test_users',
-            data={'name': 'Charlie', 'email': 'charlie@example.com', 'age': None}
-        )
+        user = User(name='Charlie', email='charlie@example.com', age=None)
+        affected_rows = await db.insert(user)
         assert affected_rows == 1
         # 验证数据已插入，且None值正确处理
         result = await db.execute_query("SELECT * FROM test_users WHERE name = 'Charlie'")
         assert len(result) == 1
+        assert is_row_dict(result[0])
         assert result[0]['email'] == 'charlie@example.com'
         assert result[0]['age'] is None
 
     @pytest.mark.asyncio
     async def test_update_by_key(self, db: Commondao) -> None:
         # 插入测试数据
-        await db.insert(
-            'test_users',
-            data={'name': 'David', 'email': 'david@example.com', 'age': 40}
-        )
+        user = User(name='David', email='david@example.com', age=40)
+        await db.insert(user)
         # 通过key更新数据
-        affected_rows = await db.update_by_key(
-            'test_users',
-            key={'name': 'David'},
-            data={'email': 'david.updated@example.com', 'age': 41}
-        )
+        updated_user = User(name='David', email='david.updated@example.com', age=41)
+        affected_rows = await db.update_by_key(updated_user, key={'name': 'David'})
         assert affected_rows == 1
         # 验证数据已更新
         result = await db.execute_query("SELECT * FROM test_users WHERE name = 'David'")
         assert len(result) == 1
+        assert is_row_dict(result[0])
         assert result[0]['email'] == 'david.updated@example.com'
         assert result[0]['age'] == 41
 
     @pytest.mark.asyncio
     async def test_update_by_key_with_none_values(self, db: Commondao) -> None:
         # 插入测试数据
-        await db.insert(
-            'test_users',
-            data={'name': 'Eve', 'email': 'eve@example.com', 'age': 22}
-        )
+        user = User(name='Eve', email='eve@example.com', age=22)
+        await db.insert(user)
         # 使用包含None值的数据更新
-        affected_rows = await db.update_by_key(
-            'test_users',
-            key={'name': 'Eve'},
-            data={'email': 'eve.updated@example.com', 'age': None}
-        )
+        updated_user = User(name='Eve', email='eve.updated@example.com', age=None)
+        affected_rows = await db.update_by_key(updated_user, key={'name': 'Eve'})
         assert affected_rows == 1
         # 验证数据已更新，但age保持原值未变
         result = await db.execute_query("SELECT * FROM test_users WHERE name = 'Eve'")
         assert len(result) == 1
+        assert is_row_dict(result[0])
         assert result[0]['email'] == 'eve.updated@example.com'
         assert result[0]['age'] == 22  # 预期age保持原值，因为update_by_key跳过None值
 
     @pytest.mark.asyncio
     async def test_update_by_key_no_change(self, db: Commondao) -> None:
         # 插入测试数据
-        await db.insert(
-            'test_users',
-            data={'name': 'Frank', 'email': 'frank@example.com', 'age': 35}
-        )
-        # 使用全部为None的数据更新（不应有变化）
-        affected_rows = await db.update_by_key(
-            'test_users',
-            key={'name': 'Frank'},
-            data={'email': None, 'age': None}
-        )
-        assert affected_rows == 0
-        # 验证数据未变
+        user = User(name='Frank', email='frank@example.com', age=35)
+        await db.insert(user)
+        # Test updating with only None age field (exclude_none=True means only age is excluded)
+        # Since email has the same value, it will still result in an UPDATE statement
+        updated_user = User(name='Frank', email='frank@example.com', age=None)
+        affected_rows = await db.update_by_key(updated_user, key={'name': 'Frank'})
+        # This will be 1 because email field is included in the update even with same value
+        assert affected_rows == 1
+        # 验证数据保持相同值
         result = await db.execute_query("SELECT * FROM test_users WHERE name = 'Frank'")
         assert len(result) == 1
+        assert is_row_dict(result[0])
         assert result[0]['email'] == 'frank@example.com'
         assert result[0]['age'] == 35
 
     @pytest.mark.asyncio
     async def test_update_by_key_nonexistent(self, db: Commondao) -> None:
         # 尝试更新不存在的记录
-        affected_rows = await db.update_by_key(
-            'test_users',
-            key={'name': 'NonExistent'},
-            data={'email': 'new@example.com', 'age': 50}
-        )
+        updated_user = User(name='NonExistent', email='new@example.com', age=50)
+        affected_rows = await db.update_by_key(updated_user, key={'name': 'NonExistent'})
         assert affected_rows == 0
 
     @pytest.mark.asyncio
     async def test_delete_by_key(self, db: Commondao) -> None:
         # 插入测试数据
-        await db.insert(
-            'test_users',
-            data={'name': 'Grace', 'email': 'grace@example.com', 'age': 28}
-        )
+        user = User(name='Grace', email='grace@example.com', age=28)
+        await db.insert(user)
         # 通过key删除数据
-        affected_rows = await db.delete_by_key(
-            'test_users',
-            key={'name': 'Grace'}
-        )
+        affected_rows = await db.delete_by_key(User, key={'name': 'Grace'})
         assert affected_rows == 1
         # 验证数据已删除
         result = await db.execute_query("SELECT * FROM test_users WHERE name = 'Grace'")
@@ -180,83 +157,70 @@ async def test_delete_by_key(self, db: Commondao) -> None:
     @pytest.mark.asyncio
     async def test_delete_by_key_composite_key(self, db: Commondao) -> None:
         # 插入两条测试数据
-        await db.insert(
-            'test_users',
-            data={'name': 'Helen', 'email': 'helen@example.com', 'age': 32}
-        )
-        await db.insert(
-            'test_users',
-            data={'name': 'Helen', 'email': 'helen2@example.com', 'age': 33}
-        )
+        user1 = User(name='Helen', email='helen@example.com', age=32)
+        user2 = User(name='Helen', email='helen2@example.com', age=33)
+        await db.insert(user1)
+        await db.insert(user2)
         # 使用组合键删除其中一条
-        affected_rows = await db.delete_by_key(
-            'test_users',
-            key={'name': 'Helen', 'age': 32}
-        )
+        affected_rows = await db.delete_by_key(User, key={'name': 'Helen', 'age': 32})
         assert affected_rows == 1
         # 验证正确的数据被删除
         result = await db.execute_query("SELECT * FROM test_users WHERE name = 'Helen'")
         assert len(result) == 1
+        assert is_row_dict(result[0])
         assert result[0]['email'] == 'helen2@example.com'
         assert result[0]['age'] == 33
 
     @pytest.mark.asyncio
     async def test_delete_by_key_nonexistent(self, db: Commondao) -> None:
         # 尝试删除不存在的记录
-        affected_rows = await db.delete_by_key(
-            'test_users',
-            key={'name': 'NonExistent'}
-        )
+        affected_rows = await db.delete_by_key(User, key={'name': 'NonExistent'})
         assert affected_rows == 0
 
     @pytest.mark.asyncio
     async def test_get_by_key(self, db: Commondao) -> None:
         # 插入测试数据
-        await db.insert(
-            'test_users',
-            data={'name': 'Ivan', 'email': 'ivan@example.com', 'age': 45}
-        )
+        user = User(name='Ivan', email='ivan@example.com', age=45)
+        await db.insert(user)
         # 通过key获取数据
-        result = await db.get_by_key('test_users', key={'name': 'Ivan'})
+        result = await db.get_by_key(User, key={'name': 'Ivan'})
         # 验证结果
         assert result is not None
-        assert result['email'] == 'ivan@example.com'
-        assert result['age'] == 45
+        assert result.email == 'ivan@example.com'
+        assert result.age == 45
 
     @pytest.mark.asyncio
     async def test_get_by_key_nonexistent(self, db: Commondao) -> None:
         # 尝试获取不存在的记录
-        result = await db.get_by_key('test_users', key={'name': 'NonExistent'})
+        result = await db.get_by_key(User, key={'name': 'NonExistent'})
         assert result is None
 
     @pytest.mark.asyncio
     async def test_get_by_key_or_fail(self, db: Commondao) -> None:
         # 插入测试数据
-        await db.insert(
-            'test_users',
-            data={'name': 'Jack', 'email': 'jack@example.com', 'age': 50}
-        )
+        user = User(name='Jack', email='jack@example.com', age=50)
+        await db.insert(user)
         # 通过key获取数据
-        result = await db.get_by_key_or_fail('test_users', key={'name': 'Jack'})
+        result = await db.get_by_key_or_fail(User, key={'name': 'Jack'})
         # 验证结果
         assert result is not None
-        assert result['email'] == 'jack@example.com'
-        assert result['age'] == 50
+        assert result.email == 'jack@example.com'
+        assert result.age == 50
 
     @pytest.mark.asyncio
     async def test_get_by_key_or_fail_nonexistent(self, db: Commondao) -> None:
-        from commondao import NotFoundError
-
         # 尝试获取不存在的记录，应抛出NotFoundError
         with pytest.raises(NotFoundError):
-            await db.get_by_key_or_fail('test_users', key={'name': 'NonExistent'})
+            await db.get_by_key_or_fail(User, key={'name': 'NonExistent'})
 
     @pytest.mark.asyncio
     async def test_multiple_keys(self, db: Commondao) -> None:
         # 插入几条测试数据
-        await db.insert('test_users', data={'name': 'Kate', 'email': 'kate@example.com', 'age': 28})
-        await db.insert('test_users', data={'name': 'Kate', 'email': 'kate2@example.com', 'age': 29})
+        user1 = User(name='Kate', email='kate@example.com', age=28)
+        user2 = User(name='Kate', email='kate2@example.com', age=29)
+        await db.insert(user1)
+        await db.insert(user2)
         # 使用组合键获取特定记录
-        result = await db.get_by_key('test_users', key={'name': 'Kate', 'age': 29})
+        result = await db.get_by_key(User, key={'name': 'Kate', 'age': 29})
         assert result is not None
-        assert result['email'] == 'kate2@example.com'
+        assert result.email == 'kate2@example.com'

tests/e2e/test_error_handling.py

@@ -1,11 +1,18 @@
 import os
-from typing import Any, AsyncGenerator, Dict
+from typing import Annotated, Any, AsyncGenerator, Dict
 
 import pytest
 import pytest_asyncio
 from pydantic import BaseModel
 
 from commondao import Commondao, NotFoundError, connect
+from commondao.annotation import TableId
+
+
+class ErrorHandlingRecord(BaseModel):
+    id: Annotated[int | None, TableId('test_error_handling')] = None
+    name: str
+    email: str | None = None
 
 
 class TestErrorHandling:
@@ -37,7 +44,7 @@ async def db(self, db_config: Dict[str, Any]) -> AsyncGenerator[Commondao, None]
     @pytest.mark.asyncio
     async def test_get_by_key_or_fail_not_found(self, db: Commondao) -> None:
         with pytest.raises(NotFoundError):
-            await db.get_by_key_or_fail('test_error_handling', key={'id': 999})
+            await db.get_by_key_or_fail(ErrorHandlingRecord, key={'id': 999})
 
     @pytest.mark.asyncio
     async def test_select_one_or_fail_not_found(self, db: Commondao) -> None:
@@ -57,7 +64,7 @@ class TestRecord(BaseModel):
 
     @pytest.mark.asyncio
     async def test_get_by_key_returns_none(self, db: Commondao) -> None:
-        result = await db.get_by_key('test_error_handling', key={'id': 999})
+        result = await db.get_by_key(ErrorHandlingRecord, key={'id': 999})
         assert result is None
 
     @pytest.mark.asyncio
@@ -78,14 +85,12 @@ class TestRecord(BaseModel):
     @pytest.mark.asyncio
     async def test_duplicate_key_error(self, db: Commondao) -> None:
         # 先插入一条记录
-        await db.insert('test_error_handling', data={'name': 'Test User', 'email': 'test@example.com'})
+        record1 = ErrorHandlingRecord(name='Test User', email='test@example.com')
+        await db.insert(record1)
 
         # 尝试插入相同的email (这应该是唯一的)
-        affected_rows = await db.insert(
-            'test_error_handling',
-            data={'name': 'Another User', 'email': 'test@example.com'},
-            ignore=True
-        )
+        record2 = ErrorHandlingRecord(name='Another User', email='test@example.com')
+        affected_rows = await db.insert(record2, ignore=True)
 
         # 使用ignore=True应该不会抛出异常，但也不会插入记录
         assert affected_rows == 0