diff options
Diffstat (limited to 'tests/test_util_typing.py')
| -rw-r--r-- | tests/test_util_typing.py | 282 |
1 files changed, 154 insertions, 128 deletions
diff --git a/tests/test_util_typing.py b/tests/test_util_typing.py index 0b2324e29..9ee217f96 100644 --- a/tests/test_util_typing.py +++ b/tests/test_util_typing.py @@ -178,156 +178,181 @@ def test_restify_mock(): def test_stringify(): - assert stringify(int, False) == "int" - assert stringify(int, True) == "int" + assert stringify(int) == "int" + assert stringify(int, "smart") == "int" - assert stringify(str, False) == "str" - assert stringify(str, True) == "str" + assert stringify(str) == "str" + assert stringify(str, "smart") == "str" - assert stringify(None, False) == "None" - assert stringify(None, True) == "None" + assert stringify(None) == "None" + assert stringify(None, "smart") == "None" - assert stringify(Integral, False) == "numbers.Integral" - assert stringify(Integral, True) == "~numbers.Integral" + assert stringify(Integral) == "numbers.Integral" + assert stringify(Integral, "smart") == "~numbers.Integral" - assert stringify(Struct, False) == "struct.Struct" - assert stringify(Struct, True) == "~struct.Struct" + assert stringify(Struct) == "struct.Struct" + assert stringify(Struct, "smart") == "~struct.Struct" - assert stringify(TracebackType, False) == "types.TracebackType" - assert stringify(TracebackType, True) == "~types.TracebackType" + assert stringify(TracebackType) == "types.TracebackType" + assert stringify(TracebackType, "smart") == "~types.TracebackType" - assert stringify(Any, False) == "Any" - assert stringify(Any, True) == "~typing.Any" + assert stringify(Any) == "Any" + assert stringify(Any, "fully-qualified") == "typing.Any" + assert stringify(Any, "smart") == "~typing.Any" def test_stringify_type_hints_containers(): - assert stringify(List, False) == "List" - assert stringify(List, True) == "~typing.List" + assert stringify(List) == "List" + assert stringify(List, "fully-qualified") == "typing.List" + assert stringify(List, "smart") == "~typing.List" - assert stringify(Dict, False) == "Dict" - assert stringify(Dict, True) == "~typing.Dict" + assert stringify(Dict) == "Dict" + assert stringify(Dict, "fully-qualified") == "typing.Dict" + assert stringify(Dict, "smart") == "~typing.Dict" - assert stringify(List[int], False) == "List[int]" - assert stringify(List[int], True) == "~typing.List[int]" + assert stringify(List[int]) == "List[int]" + assert stringify(List[int], "fully-qualified") == "typing.List[int]" + assert stringify(List[int], "smart") == "~typing.List[int]" - assert stringify(List[str], False) == "List[str]" - assert stringify(List[str], True) == "~typing.List[str]" + assert stringify(List[str]) == "List[str]" + assert stringify(List[str], "fully-qualified") == "typing.List[str]" + assert stringify(List[str], "smart") == "~typing.List[str]" - assert stringify(Dict[str, float], False) == "Dict[str, float]" - assert stringify(Dict[str, float], True) == "~typing.Dict[str, float]" + assert stringify(Dict[str, float]) == "Dict[str, float]" + assert stringify(Dict[str, float], "fully-qualified") == "typing.Dict[str, float]" + assert stringify(Dict[str, float], "smart") == "~typing.Dict[str, float]" - assert stringify(Tuple[str, str, str], False) == "Tuple[str, str, str]" - assert stringify(Tuple[str, str, str], True) == "~typing.Tuple[str, str, str]" + assert stringify(Tuple[str, str, str]) == "Tuple[str, str, str]" + assert stringify(Tuple[str, str, str], "fully-qualified") == "typing.Tuple[str, str, str]" + assert stringify(Tuple[str, str, str], "smart") == "~typing.Tuple[str, str, str]" - assert stringify(Tuple[str, ...], False) == "Tuple[str, ...]" - assert stringify(Tuple[str, ...], True) == "~typing.Tuple[str, ...]" + assert stringify(Tuple[str, ...]) == "Tuple[str, ...]" + assert stringify(Tuple[str, ...], "fully-qualified") == "typing.Tuple[str, ...]" + assert stringify(Tuple[str, ...], "smart") == "~typing.Tuple[str, ...]" - assert stringify(Tuple[()], False) == "Tuple[()]" - assert stringify(Tuple[()], True) == "~typing.Tuple[()]" + assert stringify(Tuple[()]) == "Tuple[()]" + assert stringify(Tuple[()], "fully-qualified") == "typing.Tuple[()]" + assert stringify(Tuple[()], "smart") == "~typing.Tuple[()]" - assert stringify(List[Dict[str, Tuple]], False) == "List[Dict[str, Tuple]]" - assert stringify(List[Dict[str, Tuple]], True) == "~typing.List[~typing.Dict[str, ~typing.Tuple]]" + assert stringify(List[Dict[str, Tuple]]) == "List[Dict[str, Tuple]]" + assert stringify(List[Dict[str, Tuple]], "fully-qualified") == "typing.List[typing.Dict[str, typing.Tuple]]" + assert stringify(List[Dict[str, Tuple]], "smart") == "~typing.List[~typing.Dict[str, ~typing.Tuple]]" - assert stringify(MyList[Tuple[int, int]], False) == "tests.test_util_typing.MyList[Tuple[int, int]]" - assert stringify(MyList[Tuple[int, int]], True) == "~tests.test_util_typing.MyList[~typing.Tuple[int, int]]" + assert stringify(MyList[Tuple[int, int]]) == "tests.test_util_typing.MyList[Tuple[int, int]]" + assert stringify(MyList[Tuple[int, int]], "fully-qualified") == "tests.test_util_typing.MyList[typing.Tuple[int, int]]" + assert stringify(MyList[Tuple[int, int]], "smart") == "~tests.test_util_typing.MyList[~typing.Tuple[int, int]]" - assert stringify(Generator[None, None, None], False) == "Generator[None, None, None]" - assert stringify(Generator[None, None, None], True) == "~typing.Generator[None, None, None]" + assert stringify(Generator[None, None, None]) == "Generator[None, None, None]" + assert stringify(Generator[None, None, None], "fully-qualified") == "typing.Generator[None, None, None]" + assert stringify(Generator[None, None, None], "smart") == "~typing.Generator[None, None, None]" @pytest.mark.skipif(sys.version_info < (3, 9), reason='python 3.9+ is required.') def test_stringify_type_hints_pep_585(): - assert stringify(list[int], False) == "list[int]" - assert stringify(list[int], True) == "list[int]" + assert stringify(list[int]) == "list[int]" + assert stringify(list[int], "smart") == "list[int]" - assert stringify(list[str], False) == "list[str]" - assert stringify(list[str], True) == "list[str]" + assert stringify(list[str]) == "list[str]" + assert stringify(list[str], "smart") == "list[str]" - assert stringify(dict[str, float], False) == "dict[str, float]" - assert stringify(dict[str, float], True) == "dict[str, float]" + assert stringify(dict[str, float]) == "dict[str, float]" + assert stringify(dict[str, float], "smart") == "dict[str, float]" - assert stringify(tuple[str, str, str], False) == "tuple[str, str, str]" - assert stringify(tuple[str, str, str], True) == "tuple[str, str, str]" + assert stringify(tuple[str, str, str]) == "tuple[str, str, str]" + assert stringify(tuple[str, str, str], "smart") == "tuple[str, str, str]" - assert stringify(tuple[str, ...], False) == "tuple[str, ...]" - assert stringify(tuple[str, ...], True) == "tuple[str, ...]" + assert stringify(tuple[str, ...]) == "tuple[str, ...]" + assert stringify(tuple[str, ...], "smart") == "tuple[str, ...]" - assert stringify(tuple[()], False) == "tuple[()]" - assert stringify(tuple[()], True) == "tuple[()]" + assert stringify(tuple[()]) == "tuple[()]" + assert stringify(tuple[()], "smart") == "tuple[()]" - assert stringify(list[dict[str, tuple]], False) == "list[dict[str, tuple]]" - assert stringify(list[dict[str, tuple]], True) == "list[dict[str, tuple]]" + assert stringify(list[dict[str, tuple]]) == "list[dict[str, tuple]]" + assert stringify(list[dict[str, tuple]], "smart") == "list[dict[str, tuple]]" - assert stringify(type[int], False) == "type[int]" - assert stringify(type[int], True) == "type[int]" + assert stringify(type[int]) == "type[int]" + assert stringify(type[int], "smart") == "type[int]" @pytest.mark.skipif(sys.version_info < (3, 9), reason='python 3.9+ is required.') def test_stringify_Annotated(): from typing import Annotated # type: ignore - assert stringify(Annotated[str, "foo", "bar"], False) == "str" # NOQA - assert stringify(Annotated[str, "foo", "bar"], True) == "str" # NOQA + assert stringify(Annotated[str, "foo", "bar"]) == "str" # NOQA + assert stringify(Annotated[str, "foo", "bar"], "smart") == "str" # NOQA def test_stringify_type_hints_string(): - assert stringify("int", False) == "int" - assert stringify("int", True) == "int" + assert stringify("int") == "int" + assert stringify("int", "smart") == "int" - assert stringify("str", False) == "str" - assert stringify("str", True) == "str" + assert stringify("str") == "str" + assert stringify("str", "smart") == "str" - assert stringify(List["int"], False) == "List[int]" - assert stringify(List["int"], True) == "~typing.List[int]" + assert stringify(List["int"]) == "List[int]" + assert stringify(List["int"], "smart") == "~typing.List[int]" - assert stringify("Tuple[str]", False) == "Tuple[str]" - assert stringify("Tuple[str]", True) == "Tuple[str]" + assert stringify("Tuple[str]") == "Tuple[str]" + assert stringify("Tuple[str]", "smart") == "Tuple[str]" - assert stringify("unknown", False) == "unknown" - assert stringify("unknown", True) == "unknown" + assert stringify("unknown") == "unknown" + assert stringify("unknown", "smart") == "unknown" def test_stringify_type_hints_Callable(): - assert stringify(Callable, False) == "Callable" - assert stringify(Callable, True) == "~typing.Callable" + assert stringify(Callable) == "Callable" + assert stringify(Callable, "fully-qualified") == "typing.Callable" + assert stringify(Callable, "smart") == "~typing.Callable" if sys.version_info >= (3, 7): - assert stringify(Callable[[str], int], False) == "Callable[[str], int]" - assert stringify(Callable[[str], int], True) == "~typing.Callable[[str], int]" + assert stringify(Callable[[str], int]) == "Callable[[str], int]" + assert stringify(Callable[[str], int], "fully-qualified") == "typing.Callable[[str], int]" + assert stringify(Callable[[str], int], "smart") == "~typing.Callable[[str], int]" - assert stringify(Callable[..., int], False) == "Callable[[...], int]" - assert stringify(Callable[..., int], True) == "~typing.Callable[[...], int]" + assert stringify(Callable[..., int]) == "Callable[[...], int]" + assert stringify(Callable[..., int], "fully-qualified") == "typing.Callable[[...], int]" + assert stringify(Callable[..., int], "smart") == "~typing.Callable[[...], int]" else: - assert stringify(Callable[[str], int], False) == "Callable[str, int]" - assert stringify(Callable[[str], int], True) == "~typing.Callable[str, int]" + assert stringify(Callable[[str], int]) == "Callable[str, int]" + assert stringify(Callable[[str], int], "fully-qualified") == "typing.Callable[str, int]" + assert stringify(Callable[[str], int], "smart") == "~typing.Callable[str, int]" - assert stringify(Callable[..., int], False) == "Callable[..., int]" - assert stringify(Callable[..., int], True) == "~typing.Callable[..., int]" + assert stringify(Callable[..., int]) == "Callable[..., int]" + assert stringify(Callable[..., int], "fully-qualified") == "typing.Callable[..., int]" + assert stringify(Callable[..., int], "smart") == "~typing.Callable[..., int]" def test_stringify_type_hints_Union(): - assert stringify(Optional[int], False) == "Optional[int]" - assert stringify(Optional[int], True) == "~typing.Optional[int]" + assert stringify(Optional[int]) == "Optional[int]" + assert stringify(Optional[int], "fully-qualified") == "typing.Optional[int]" + assert stringify(Optional[int], "smart") == "~typing.Optional[int]" - assert stringify(Union[str, None], False) == "Optional[str]" - assert stringify(Union[str, None], True) == "~typing.Optional[str]" + assert stringify(Union[str, None]) == "Optional[str]" + assert stringify(Union[str, None], "fully-qualified") == "typing.Optional[str]" + assert stringify(Union[str, None], "smart") == "~typing.Optional[str]" - assert stringify(Union[int, str], False) == "Union[int, str]" - assert stringify(Union[int, str], True) == "~typing.Union[int, str]" + assert stringify(Union[int, str]) == "Union[int, str]" + assert stringify(Union[int, str], "fully-qualified") == "typing.Union[int, str]" + assert stringify(Union[int, str], "smart") == "~typing.Union[int, str]" if sys.version_info >= (3, 7): - assert stringify(Union[int, Integral], False) == "Union[int, numbers.Integral]" - assert stringify(Union[int, Integral], True) == "~typing.Union[int, ~numbers.Integral]" + assert stringify(Union[int, Integral]) == "Union[int, numbers.Integral]" + assert stringify(Union[int, Integral], "fully-qualified") == "typing.Union[int, numbers.Integral]" + assert stringify(Union[int, Integral], "smart") == "~typing.Union[int, ~numbers.Integral]" - assert (stringify(Union[MyClass1, MyClass2], False) == + assert (stringify(Union[MyClass1, MyClass2]) == "Union[tests.test_util_typing.MyClass1, tests.test_util_typing.<MyClass2>]") - assert (stringify(Union[MyClass1, MyClass2], True) == + assert (stringify(Union[MyClass1, MyClass2], "fully-qualified") == + "typing.Union[tests.test_util_typing.MyClass1, tests.test_util_typing.<MyClass2>]") + assert (stringify(Union[MyClass1, MyClass2], "smart") == "~typing.Union[~tests.test_util_typing.MyClass1, ~tests.test_util_typing.<MyClass2>]") else: - assert stringify(Union[int, Integral], False) == "numbers.Integral" - assert stringify(Union[int, Integral], True) == "~numbers.Integral" + assert stringify(Union[int, Integral]) == "numbers.Integral" + assert stringify(Union[int, Integral], "fully-qualified") == "numbers.Integral" + assert stringify(Union[int, Integral], "smart") == "~numbers.Integral" - assert stringify(Union[MyClass1, MyClass2], False) == "tests.test_util_typing.MyClass1" - assert stringify(Union[MyClass1, MyClass2], True) == "~tests.test_util_typing.MyClass1" + assert stringify(Union[MyClass1, MyClass2]) == "tests.test_util_typing.MyClass1" + assert stringify(Union[MyClass1, MyClass2], "fully-qualified") == "tests.test_util_typing.MyClass1" + assert stringify(Union[MyClass1, MyClass2], "smart") == "~tests.test_util_typing.MyClass1" def test_stringify_type_hints_typevars(): @@ -336,83 +361,84 @@ def test_stringify_type_hints_typevars(): T_contra = TypeVar('T_contra', contravariant=True) if sys.version_info < (3, 7): - assert stringify(T, False) == "T" - assert stringify(T, True) == "T" + assert stringify(T) == "T" + assert stringify(T, "smart") == "T" - assert stringify(T_co, False) == "T_co" - assert stringify(T_co, True) == "T_co" + assert stringify(T_co) == "T_co" + assert stringify(T_co, "smart") == "T_co" - assert stringify(T_contra, False) == "T_contra" - assert stringify(T_contra, True) == "T_contra" + assert stringify(T_contra) == "T_contra" + assert stringify(T_contra, "smart") == "T_contra" - assert stringify(List[T], False) == "List[T]" - assert stringify(List[T], True) == "~typing.List[T]" + assert stringify(List[T]) == "List[T]" + assert stringify(List[T], "smart") == "~typing.List[T]" else: - assert stringify(T, False) == "tests.test_util_typing.T" - assert stringify(T, True) == "~tests.test_util_typing.T" + assert stringify(T) == "tests.test_util_typing.T" + assert stringify(T, "smart") == "~tests.test_util_typing.T" - assert stringify(T_co, False) == "tests.test_util_typing.T_co" - assert stringify(T_co, True) == "~tests.test_util_typing.T_co" + assert stringify(T_co) == "tests.test_util_typing.T_co" + assert stringify(T_co, "smart") == "~tests.test_util_typing.T_co" - assert stringify(T_contra, False) == "tests.test_util_typing.T_contra" - assert stringify(T_contra, True) == "~tests.test_util_typing.T_contra" + assert stringify(T_contra) == "tests.test_util_typing.T_contra" + assert stringify(T_contra, "smart") == "~tests.test_util_typing.T_contra" - assert stringify(List[T], False) == "List[tests.test_util_typing.T]" - assert stringify(List[T], True) == "~typing.List[~tests.test_util_typing.T]" + assert stringify(List[T]) == "List[tests.test_util_typing.T]" + assert stringify(List[T], "smart") == "~typing.List[~tests.test_util_typing.T]" if sys.version_info >= (3, 10): - assert stringify(MyInt, False) == "tests.test_util_typing.MyInt" - assert stringify(MyInt, True) == "~tests.test_util_typing.MyInt" + assert stringify(MyInt) == "tests.test_util_typing.MyInt" + assert stringify(MyInt, "smart") == "~tests.test_util_typing.MyInt" else: - assert stringify(MyInt, False) == "MyInt" - assert stringify(MyInt, True) == "MyInt" + assert stringify(MyInt) == "MyInt" + assert stringify(MyInt, "smart") == "MyInt" def test_stringify_type_hints_custom_class(): - assert stringify(MyClass1, False) == "tests.test_util_typing.MyClass1" - assert stringify(MyClass1, True) == "~tests.test_util_typing.MyClass1" + assert stringify(MyClass1) == "tests.test_util_typing.MyClass1" + assert stringify(MyClass1, "smart") == "~tests.test_util_typing.MyClass1" - assert stringify(MyClass2, False) == "tests.test_util_typing.<MyClass2>" - assert stringify(MyClass2, True) == "~tests.test_util_typing.<MyClass2>" + assert stringify(MyClass2) == "tests.test_util_typing.<MyClass2>" + assert stringify(MyClass2, "smart") == "~tests.test_util_typing.<MyClass2>" def test_stringify_type_hints_alias(): MyStr = str MyTuple = Tuple[str, str] - assert stringify(MyStr, False) == "str" - assert stringify(MyStr, True) == "str" + assert stringify(MyStr) == "str" + assert stringify(MyStr, "smart") == "str" - assert stringify(MyTuple, False) == "Tuple[str, str]" # type: ignore - assert stringify(MyTuple, True) == "~typing.Tuple[str, str]" # type: ignore + assert stringify(MyTuple) == "Tuple[str, str]" # type: ignore + assert stringify(MyTuple, "smart") == "~typing.Tuple[str, str]" # type: ignore @pytest.mark.skipif(sys.version_info < (3, 8), reason='python 3.8+ is required.') def test_stringify_type_Literal(): from typing import Literal # type: ignore - assert stringify(Literal[1, "2", "\r"], False) == "Literal[1, '2', '\\r']" - assert stringify(Literal[1, "2", "\r"], True) == "~typing.Literal[1, '2', '\\r']" + assert stringify(Literal[1, "2", "\r"]) == "Literal[1, '2', '\\r']" + assert stringify(Literal[1, "2", "\r"], "fully-qualified") == "typing.Literal[1, '2', '\\r']" + assert stringify(Literal[1, "2", "\r"], "smart") == "~typing.Literal[1, '2', '\\r']" @pytest.mark.skipif(sys.version_info < (3, 10), reason='python 3.10+ is required.') def test_stringify_type_union_operator(): - assert stringify(int | None, False) == "int | None" # type: ignore - assert stringify(int | None, True) == "int | None" # type: ignore + assert stringify(int | None) == "int | None" # type: ignore + assert stringify(int | None, "smart") == "int | None" # type: ignore - assert stringify(int | str, False) == "int | str" # type: ignore - assert stringify(int | str, True) == "int | str" # type: ignore + assert stringify(int | str) == "int | str" # type: ignore + assert stringify(int | str, "smart") == "int | str" # type: ignore - assert stringify(int | str | None, False) == "int | str | None" # type: ignore - assert stringify(int | str | None, True) == "int | str | None" # type: ignore + assert stringify(int | str | None) == "int | str | None" # type: ignore + assert stringify(int | str | None, "smart") == "int | str | None" # type: ignore def test_stringify_broken_type_hints(): - assert stringify(BrokenType, False) == 'tests.test_util_typing.BrokenType' - assert stringify(BrokenType, True) == '~tests.test_util_typing.BrokenType' + assert stringify(BrokenType) == 'tests.test_util_typing.BrokenType' + assert stringify(BrokenType, "smart") == '~tests.test_util_typing.BrokenType' def test_stringify_mock(): with mock(['unknown']): import unknown - assert stringify(unknown.secret.Class, False) == 'unknown.secret.Class' - assert stringify(unknown.secret.Class, True) == 'unknown.secret.Class' + assert stringify(unknown.secret.Class) == 'unknown.secret.Class' + assert stringify(unknown.secret.Class, "smart") == 'unknown.secret.Class' |