✅ add test cases

nonebot/__init__.py

@@ -43,7 +43,7 @@ try:
     _dist: pkg_resources.Distribution = pkg_resources.get_distribution("nonebot2")
     __version__ = _dist.version
     VERSION = _dist.parsed_version
-except pkg_resources.DistributionNotFound:
+except pkg_resources.DistributionNotFound:  # pragma: no cover
     __version__ = None
     VERSION = None
 
@@ -252,7 +252,7 @@ def init(*, _env_file: Optional[str] = None, **kwargs):
         _driver = DriverClass(env, config)
 
 
-def run(host: Optional[str] = None, port: Optional[int] = None, *args, **kwargs):
+def run(*args: Any, **kwargs: Any) -> None:
     """
     :说明:
 
@@ -260,8 +260,6 @@ def run(host: Optional[str] = None, port: Optional[int] = None, *args, **kwargs)
 
     :参数:
 
-      * ``host: Optional[str]``: 主机名／IP，若不传入则使用配置文件中指定的值
-      * ``port: Optional[int]``: 端口，若不传入则使用配置文件中指定的值
       * ``*args``: 传入 Driver.run 的位置参数
       * ``**kwargs``: 传入 Driver.run 的命名参数
 
@@ -277,7 +275,7 @@ def run(host: Optional[str] = None, port: Optional[int] = None, *args, **kwargs)
 
     """
     logger.success("Running NoneBot...")
-    get_driver().run(host, port, *args, **kwargs)
+    get_driver().run(*args, **kwargs)
 
 
 import nonebot.params as params

nonebot/config.py

@@ -38,7 +38,7 @@ class CustomEnvSettings(EnvSettingsSource):
         d: Dict[str, Optional[str]] = {}
 
         if settings.__config__.case_sensitive:
-            env_vars: Mapping[str, Optional[str]] = os.environ
+            env_vars: Mapping[str, Optional[str]] = os.environ  # pragma: no cover
         else:
             env_vars = {k.lower(): v for k, v in os.environ.items()}
 
@@ -78,7 +78,7 @@ class CustomEnvSettings(EnvSettingsSource):
             if field.is_complex():
                 try:
                     env_val = settings.__config__.json_loads(env_val)
-                except ValueError as e:
+                except ValueError as e:  # pragma: no cover
                     raise SettingsError(
                         f'error parsing JSON for "{env_name}"'  # type: ignore
                     ) from e
@@ -100,7 +100,8 @@ class CustomEnvSettings(EnvSettingsSource):
 
 
 class BaseConfig(BaseSettings):
-    def __getattr__(self, name: str) -> Any:
+    # dummy getattr for pylance checking, actually not used
+    def __getattr__(self, name: str) -> Any:  # pragma: no cover
         return self.__dict__.get(name)
 
     class Config:

nonebot/log.py

@@ -63,7 +63,7 @@ class Filter:
         return record["level"].no >= levelno
 
 
-class LoguruHandler(logging.Handler):
+class LoguruHandler(logging.Handler):  # pragma: no cover
     def emit(self, record):
         try:
             level = logger.level(record.levelname).name

tests/.coveragerc

@@ -0,0 +1,6 @@
+[report]
+exclude_lines =
+  pragma: no cover
+  if TYPE_CHECKING:
+  @(abc\.)?abstractmethod
+  raise NotImplementedError

tests/.env.test

@@ -1 +1,2 @@
+NICKNAME=["test"]
 CONFIG_FROM_ENV=

tests/plugins/export.py

@@ -0,0 +1,6 @@
+from nonebot import export
+
+
+@export()
+def test():
+    ...

tests/plugins/require.py

@@ -0,0 +1,8 @@
+from nonebot import require
+
+from plugins.export import test
+from .export import test as test_related
+
+test_require = require("export").test
+
+assert test is test_related and test is test_require, "Export Require Error"

tests/pyproject.toml

@@ -0,0 +1,2 @@
+[tool.isort]
+known_local_folder = ["plugins"]

tests/test_init.py

@@ -1,30 +1,81 @@
 import os
 import sys
+from re import A
 from typing import TYPE_CHECKING, Set
 
 import pytest
+
 from utils import load_plugin
 
 if TYPE_CHECKING:
     from nonebot.plugin import Plugin
 
-os.environ["CONFIG_FROM_ENV"] = "env"
+os.environ["CONFIG_FROM_ENV"] = '{"test": "test"}'
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("nonebug_init", [{"config_from_init": "init"}], indirect=True)
+@pytest.mark.parametrize(
+    "nonebug_init",
+    [{"config_from_init": "init", "driver": "nonebot.drivers.fastapi:FullDriver"}],
+    indirect=True,
+)
 async def test_init(nonebug_init):
     from nonebot import get_driver
+    from nonebot.drivers.fastapi import FullDriver
 
     env = get_driver().env
     assert env == "test"
 
+    assert isinstance(get_driver(), FullDriver)
+
     config = get_driver().config
-    assert config.config_from_env == "env"
+    assert config.config_from_env == {"test": "test"}
     assert config.config_from_init == "init"
     assert config.common_config == "common"
 
 
+@pytest.mark.asyncio
+async def test_get(monkeypatch: pytest.MonkeyPatch, nonebug_clear):
+    import nonebot
+    from nonebot.drivers import ForwardDriver, ReverseDriver
+    from nonebot import get_app, get_bot, get_asgi, get_bots, get_driver
+
+    try:
+        get_driver()
+        assert False, "Driver can only be got after initialization"
+    except ValueError:
+        assert True
+
+    nonebot.init(driver="nonebot.drivers.fastapi")
+
+    driver = get_driver()
+    assert isinstance(driver, ReverseDriver)
+    assert get_asgi() == driver.asgi
+    assert get_app() == driver.server_app
+
+    runned = False
+
+    def mock_run(*args, **kwargs):
+        nonlocal runned
+        runned = True
+        assert args == ("arg",) and kwargs == {"kwarg": "kwarg"}
+
+    monkeypatch.setattr(driver, "run", mock_run)
+    nonebot.run("arg", kwarg="kwarg")
+    assert runned
+
+    try:
+        get_bot()
+        assert False
+    except ValueError:
+        assert True
+
+    monkeypatch.setattr(driver, "_clients", {"test": "test"})
+    assert get_bot() == "test"
+    assert get_bot("test") == "test"
+    assert get_bots() == {"test": "test"}
+
+
 @pytest.mark.asyncio
 async def test_load_plugin(load_plugin: Set["Plugin"]):
     import nonebot