添加单测

.github/workflows/pr-check.yml

@@ -7,7 +7,7 @@ on:
   pull_request:
 
 jobs:
-  test-api-only:
+  test:
 
     strategy:
       fail-fast: false
@@ -29,36 +29,3 @@ jobs:
         pip install -r requirements.txt
     - name: Test with pytest
       run: pytest
-
-#  test-full:
-#
-#    strategy:
-#      fail-fast: false
-#      matrix:
-#        os: [ macos-latest, windows-latest, ubuntu-latest ]
-#        python-version: ["3.9", "3.10", "3.11", "3.12"]
-#
-#    runs-on: ${{ matrix.os }}
-#    steps:
-#    - name: Checkout nonebot-plugin-access-control
-#      uses: actions/checkout@v3
-#      with:
-#        repository: 'bot-ssttkkl/nonebot-plugin-access-control'
-#    - name: Set up Python ${{ matrix.python-version }}
-#      uses: actions/setup-python@v3
-#      with:
-#        python-version: ${{ matrix.python-version }}
-#    - name: Install requirements
-#      run: |
-#        pip install poetry
-#        poetry export --with=dev --without-hashes -o requirements.txt
-#        pip install -r requirements.txt
-#    - name: Checkout nonebot-plugin-access-control-api
-#      uses: actions/checkout@v3
-#      with:
-#        path: 'nonebot-plugin-access-control-api'
-#    - name: Install nonebot-plugin-access-control-api
-#      run: |
-#        pip install ./nonebot-plugin-access-control-api
-#    - name: Test with pytest
-#      run: pytest ./src/tests

nonebot_plugin_nagabus/data/mjs.py

@@ -1,4 +1,6 @@
 import json
+from collections.abc import Awaitable
+from typing import Any, Callable, Optional
 
 from nonebot import logger
 from sqlalchemy import select
@@ -7,7 +9,7 @@
 
 from .base import SqlModel
 from ..data.utils import insert
-from ..data.session import get_session
+from .utils.session import _use_session
 
 
 class MajsoulPaipuOrm(SqlModel):
@@ -18,26 +20,39 @@ class MajsoulPaipuOrm(SqlModel):
     content: Mapped[str]
 
 
+# 为了方便单测时mock实现
+_get_majsoul_paipu_delegate: Optional[Callable[[str], Awaitable[Any]]] = None
+
+
+def _set_get_majsoul_paipu_delegate(get_majsoul_paipu_delegate):
+    global _get_majsoul_paipu_delegate
+    _get_majsoul_paipu_delegate = get_majsoul_paipu_delegate
+
+
 async def get_majsoul_paipu(uuid: str):
-    sess = get_session()
+    if _get_majsoul_paipu_delegate is not None:
+        return await _get_majsoul_paipu_delegate(uuid)
 
-    stmt = select(MajsoulPaipuOrm).where(MajsoulPaipuOrm.paipu_uuid == uuid).limit(1)
-    res = (await sess.execute(stmt)).scalar_one_or_none()
+    async with _use_session() as sess:
+        stmt = (
+            select(MajsoulPaipuOrm).where(MajsoulPaipuOrm.paipu_uuid == uuid).limit(1)
+        )
+        res = (await sess.execute(stmt)).scalar_one_or_none()
 
-    if res is not None:
-        logger.opt(colors=True).info(f"Use cached majsoul paipu <y>{uuid}</y>")
-        return json.loads(res.content)
+        if res is not None:
+            logger.opt(colors=True).info(f"Use cached majsoul paipu <y>{uuid}</y>")
+            return json.loads(res.content)
 
-    logger.opt(colors=True).info(f"Downloading majsoul paipu <y>{uuid}</y> ...")
-    data = await download_paipu(uuid)
+        logger.opt(colors=True).info(f"Downloading majsoul paipu <y>{uuid}</y> ...")
+        data = await download_paipu(uuid)
 
-    stmt = (
-        insert(MajsoulPaipuOrm)
-        .values(paipu_uuid=uuid, content=json.dumps(data))
-        .on_conflict_do_nothing(index_elements=[MajsoulPaipuOrm.paipu_uuid])
-    )
+        stmt = (
+            insert(MajsoulPaipuOrm)
+            .values(paipu_uuid=uuid, content=json.dumps(data))
+            .on_conflict_do_nothing(index_elements=[MajsoulPaipuOrm.paipu_uuid])
+        )
 
-    await sess.execute(stmt)
-    await sess.commit()
+        await sess.execute(stmt)
+        await sess.commit()
 
-    return data
+        return data

nonebot_plugin_nagabus/data/naga.py

@@ -9,7 +9,7 @@
 
 from .base import SqlModel
 from .utils import UTCDateTime
-from .session import get_session
+from .utils.session import _use_session
 from ..naga.model import NagaReport, NagaGameRule, NagaOrderStatus
 
 
@@ -55,48 +55,48 @@ class MajsoulOrderOrm(SqlModel):
 
 
 async def get_orders(t_begin: datetime, t_end: datetime) -> list[NagaOrderOrm]:
-    sess = get_session()
-    stmt = select(NagaOrderOrm).where(
-        NagaOrderOrm.create_time >= t_begin,
-        NagaOrderOrm.create_time < t_end,
-        NagaOrderOrm.status == NagaOrderStatus.ok,
-    )
-    return list((await sess.execute(stmt)).scalars())
+    async with _use_session() as sess:
+        stmt = select(NagaOrderOrm).where(
+            NagaOrderOrm.create_time >= t_begin,
+            NagaOrderOrm.create_time < t_end,
+            NagaOrderOrm.status == NagaOrderStatus.ok,
+        )
+        return list((await sess.execute(stmt)).scalars())
 
 
 async def get_local_majsoul_order(
     majsoul_uuid: str, kyoku: int, honba: int, model_type: str
 ) -> Optional[NagaOrderOrm]:
-    sess = get_session()
-    stmt = select(MajsoulOrderOrm).where(
-        MajsoulOrderOrm.paipu_uuid == majsoul_uuid,
-        MajsoulOrderOrm.kyoku == kyoku,
-        MajsoulOrderOrm.honba == honba,
-        MajsoulOrderOrm.model_type == model_type,
-    )
+    async with _use_session() as sess:
+        stmt = select(MajsoulOrderOrm).where(
+            MajsoulOrderOrm.paipu_uuid == majsoul_uuid,
+            MajsoulOrderOrm.kyoku == kyoku,
+            MajsoulOrderOrm.honba == honba,
+            MajsoulOrderOrm.model_type == model_type,
+        )
 
-    order_orm: Optional[MajsoulOrderOrm] = (
-        await sess.execute(stmt)
-    ).scalar_one_or_none()
-    if order_orm is not None:
-        if (
-            order_orm.order.status == NagaOrderStatus.ok
-            or datetime.now(tz=timezone.utc).timestamp()
-            - order_orm.order.update_time.timestamp()
-            < 90
-        ):
-            return order_orm.order
-        else:  # 超过90s仍未分析完成则删除重来
-            logger.opt(colors=True).info(
-                f"Delete majsoul paipu <y>{majsoul_uuid} "
-                f"(kyoku: {kyoku}, honba: {honba})</y> "
-                f"analyze order: {order_orm.naga_haihu_id}, "
-                f"because it takes over 90 seconds and still not done"
-            )
-            await sess.delete(order_orm.order)
-            await sess.delete(order_orm)
-            await sess.commit()
-            return None
+        order_orm: Optional[MajsoulOrderOrm] = (
+            await sess.execute(stmt)
+        ).scalar_one_or_none()
+        if order_orm is not None:
+            if (
+                order_orm.order.status == NagaOrderStatus.ok
+                or datetime.now(tz=timezone.utc).timestamp()
+                - order_orm.order.update_time.timestamp()
+                < 90
+            ):
+                return order_orm.order
+            else:  # 超过90s仍未分析完成则删除重来
+                logger.opt(colors=True).info(
+                    f"Delete majsoul paipu <y>{majsoul_uuid} "
+                    f"(kyoku: {kyoku}, honba: {honba})</y> "
+                    f"analyze order: {order_orm.naga_haihu_id}, "
+                    f"because it takes over 90 seconds and still not done"
+                )
+                await sess.delete(order_orm.order)
+                await sess.delete(order_orm)
+                await sess.commit()
+                return None
 
 
 async def new_local_majsoul_order(
@@ -107,102 +107,104 @@ async def new_local_majsoul_order(
     honba: int,
     model_type: str,
 ):
-    sess = get_session()
-    order_orm = NagaOrderOrm(
-        haihu_id=haihu_id,
-        customer_id=customer_id,
-        cost_np=10,
-        source=NagaOrderSource.majsoul,
-        model_type=model_type,
-        status=NagaOrderStatus.analyzing,
-        create_time=datetime.now(tz=timezone.utc),
-        update_time=datetime.now(tz=timezone.utc),
-    )
+    async with _use_session() as sess:
+        order_orm = NagaOrderOrm(
+            haihu_id=haihu_id,
+            customer_id=customer_id,
+            cost_np=10,
+            source=NagaOrderSource.majsoul,
+            model_type=model_type,
+            status=NagaOrderStatus.analyzing,
+            create_time=datetime.now(tz=timezone.utc),
+            update_time=datetime.now(tz=timezone.utc),
+        )
 
-    majsoul_order_orm = MajsoulOrderOrm(
-        naga_haihu_id=haihu_id,
-        paipu_uuid=majsoul_uuid,
-        kyoku=kyoku,
-        honba=honba,
-        model_type=model_type,
-        order=order_orm,
-    )
+        majsoul_order_orm = MajsoulOrderOrm(
+            naga_haihu_id=haihu_id,
+            paipu_uuid=majsoul_uuid,
+            kyoku=kyoku,
+            honba=honba,
+            model_type=model_type,
+            order=order_orm,
+        )
 
-    sess.add(order_orm)
-    sess.add(majsoul_order_orm)
-    await sess.commit()
+        sess.add(order_orm)
+        sess.add(majsoul_order_orm)
+        await sess.commit()
 
 
 async def update_local_majsoul_order(haihu_id: str, report: NagaReport):
-    sess = get_session()
-    stmt = (
-        update(NagaOrderOrm)
-        .where(NagaOrderOrm.haihu_id == haihu_id)
-        .values(
-            status=NagaOrderStatus.ok,
-            naga_report=json.dumps(report),
-            update_time=datetime.now(timezone.utc),
+    async with _use_session() as sess:
+        stmt = (
+            update(NagaOrderOrm)
+            .where(NagaOrderOrm.haihu_id == haihu_id)
+            .values(
+                status=NagaOrderStatus.ok,
+                naga_report=json.dumps(report),
+                update_time=datetime.now(timezone.utc),
+            )
         )
-    )
-    await sess.execute(stmt)
-    await sess.commit()
+        await sess.execute(stmt)
+        await sess.commit()
 
 
 async def get_local_order(haihu_id: str, model_type: str) -> Optional[NagaOrderOrm]:
-    sess = get_session()
-    stmt = select(NagaOrderOrm).where(
-        NagaOrderOrm.haihu_id == haihu_id,
-        NagaOrderOrm.model_type == model_type,
-    )
+    async with _use_session() as sess:
+        stmt = select(NagaOrderOrm).where(
+            NagaOrderOrm.haihu_id == haihu_id,
+            NagaOrderOrm.model_type == model_type,
+        )
 
-    order_orm: Optional[NagaOrderOrm] = (await sess.execute(stmt)).scalar_one_or_none()
-    if order_orm is not None:
-        if (
-            order_orm.status == NagaOrderStatus.ok
-            or datetime.now(tz=timezone.utc).timestamp()
-            - order_orm.update_time.timestamp()
-            < 300
-        ):
-            return order_orm
-        else:  # 超过90s仍未分析完成则删除重来
-            logger.opt(colors=True).info(
-                f"Delete tenhou paipu <y>{haihu_id}</y> analyze order "
-                f"because it takes over 90 seconds and still not done"
-            )
-            await sess.delete(order_orm)
-            await sess.commit()
-            return None
+        order_orm: Optional[NagaOrderOrm] = (
+            await sess.execute(stmt)
+        ).scalar_one_or_none()
+        if order_orm is not None:
+            if (
+                order_orm.status == NagaOrderStatus.ok
+                or datetime.now(tz=timezone.utc).timestamp()
+                - order_orm.update_time.timestamp()
+                < 300
+            ):
+                return order_orm
+            else:  # 超过90s仍未分析完成则删除重来
+                logger.opt(colors=True).info(
+                    f"Delete tenhou paipu <y>{haihu_id}</y> analyze order "
+                    f"because it takes over 90 seconds and still not done"
+                )
+                await sess.delete(order_orm)
+                await sess.commit()
+                return None
 
 
 async def new_local_order(
     haihu_id: str, customer_id: int, rule: NagaGameRule, model_type: str
 ):
-    sess = get_session()
-    order_orm = NagaOrderOrm(
-        haihu_id=haihu_id,
-        customer_id=customer_id,
-        cost_np=50 if rule == NagaGameRule.hanchan else 30,
-        source=NagaOrderSource.tenhou,
-        model_type=model_type,
-        status=NagaOrderStatus.analyzing,
-        create_time=datetime.now(tz=timezone.utc),
-        update_time=datetime.now(tz=timezone.utc),
-    )
+    async with _use_session() as sess:
+        order_orm = NagaOrderOrm(
+            haihu_id=haihu_id,
+            customer_id=customer_id,
+            cost_np=50 if rule == NagaGameRule.hanchan else 30,
+            source=NagaOrderSource.tenhou,
+            model_type=model_type,
+            status=NagaOrderStatus.analyzing,
+            create_time=datetime.now(tz=timezone.utc),
+            update_time=datetime.now(tz=timezone.utc),
+        )
 
-    sess.add(order_orm)
-    await sess.commit()
+        sess.add(order_orm)
+        await sess.commit()
 
 
 async def update_local_order(haihu_id: str, report: NagaReport):
-    sess = get_session()
-    stmt = (
-        update(NagaOrderOrm)
-        .where(NagaOrderOrm.haihu_id == haihu_id)
-        .values(
-            status=NagaOrderStatus.ok,
-            naga_report=json.dumps(report),
-            update_time=datetime.now(timezone.utc),
+    async with _use_session() as sess:
+        stmt = (
+            update(NagaOrderOrm)
+            .where(NagaOrderOrm.haihu_id == haihu_id)
+            .values(
+                status=NagaOrderStatus.ok,
+                naga_report=json.dumps(report),
+                update_time=datetime.now(timezone.utc),
+            )
         )
-    )
-    await sess.execute(stmt)
-    await sess.commit()
+        await sess.execute(stmt)
+        await sess.commit()