mirror of
https://github.com/nonebot/nonebot2.git
synced 2024-12-04 02:54:49 +08:00
124 lines
3.5 KiB
Python
124 lines
3.5 KiB
Python
import json
|
|
from typing import ClassVar, Dict, List, Literal, TypeVar, Union # noqa: UP035
|
|
|
|
from nonebot.utils import (
|
|
DataclassEncoder,
|
|
escape_tag,
|
|
generic_check_issubclass,
|
|
is_async_gen_callable,
|
|
is_coroutine_callable,
|
|
is_gen_callable,
|
|
)
|
|
from utils import FakeMessage, FakeMessageSegment
|
|
|
|
|
|
def test_loguru_escape_tag():
|
|
assert escape_tag("<red>red</red>") == r"\<red>red\</red>"
|
|
assert escape_tag("<fg #fff>white</fg #fff>") == r"\<fg #fff>white\</fg #fff>"
|
|
assert escape_tag("<fg\n#fff>white</fg\n#fff>") == "\\<fg\n#fff>white\\</fg\n#fff>"
|
|
assert escape_tag("<bg #fff>white</bg #fff>") == r"\<bg #fff>white\</bg #fff>"
|
|
assert escape_tag("<bg\n#fff>white</bg\n#fff>") == "\\<bg\n#fff>white\\</bg\n#fff>"
|
|
|
|
|
|
def test_generic_check_issubclass():
|
|
assert generic_check_issubclass(int, (int, float))
|
|
assert not generic_check_issubclass(str, (int, float))
|
|
assert generic_check_issubclass(Union[int, float, None], (int, float))
|
|
assert generic_check_issubclass(Literal[1, 2, 3], int)
|
|
assert not generic_check_issubclass(Literal[1, 2, "3"], int)
|
|
assert generic_check_issubclass(List[int], list) # noqa: UP006
|
|
assert generic_check_issubclass(Dict[str, int], dict) # noqa: UP006
|
|
assert generic_check_issubclass(list[int], list)
|
|
assert generic_check_issubclass(dict[str, int], dict)
|
|
assert not generic_check_issubclass(ClassVar[int], int)
|
|
assert generic_check_issubclass(TypeVar("T", int, float), (int, float))
|
|
assert generic_check_issubclass(TypeVar("T", bound=int), (int, float))
|
|
|
|
|
|
def test_is_coroutine_callable():
|
|
async def test1(): ...
|
|
|
|
def test2(): ...
|
|
|
|
class TestClass1:
|
|
async def __call__(self): ...
|
|
|
|
class TestClass2:
|
|
def __call__(self): ...
|
|
|
|
assert is_coroutine_callable(test1)
|
|
assert not is_coroutine_callable(test2)
|
|
assert not is_coroutine_callable(TestClass1)
|
|
assert is_coroutine_callable(TestClass1())
|
|
assert not is_coroutine_callable(TestClass2)
|
|
|
|
|
|
def test_is_gen_callable():
|
|
def test1():
|
|
yield
|
|
|
|
async def test2():
|
|
yield
|
|
|
|
def test3(): ...
|
|
|
|
class TestClass1:
|
|
def __call__(self):
|
|
yield
|
|
|
|
class TestClass2:
|
|
async def __call__(self):
|
|
yield
|
|
|
|
class TestClass3:
|
|
def __call__(self): ...
|
|
|
|
assert is_gen_callable(test1)
|
|
assert not is_gen_callable(test2)
|
|
assert not is_gen_callable(test3)
|
|
assert is_gen_callable(TestClass1())
|
|
assert not is_gen_callable(TestClass2())
|
|
assert not is_gen_callable(TestClass3())
|
|
|
|
|
|
def test_is_async_gen_callable():
|
|
async def test1():
|
|
yield
|
|
|
|
def test2():
|
|
yield
|
|
|
|
async def test3(): ...
|
|
|
|
class TestClass1:
|
|
async def __call__(self):
|
|
yield
|
|
|
|
class TestClass2:
|
|
def __call__(self):
|
|
yield
|
|
|
|
class TestClass3:
|
|
async def __call__(self): ...
|
|
|
|
assert is_async_gen_callable(test1)
|
|
assert not is_async_gen_callable(test2)
|
|
assert not is_async_gen_callable(test3)
|
|
assert is_async_gen_callable(TestClass1())
|
|
assert not is_async_gen_callable(TestClass2())
|
|
assert not is_async_gen_callable(TestClass3())
|
|
|
|
|
|
def test_dataclass_encoder():
|
|
simple = json.dumps("123", cls=DataclassEncoder)
|
|
assert simple == '"123"'
|
|
|
|
ms = FakeMessageSegment.nested(FakeMessage(FakeMessageSegment.text("text")))
|
|
s = json.dumps(ms, cls=DataclassEncoder)
|
|
assert s == (
|
|
"{"
|
|
'"type": "node", '
|
|
'"data": {"content": [{"type": "text", "data": {"text": "text"}}]}'
|
|
"}"
|
|
)
|