Add typing tests for describe_call, repred, and superrepr

Author: Евгений Блинов

tests/typing/__init__.py

@@ -0,0 +1,122 @@
+import pytest
+from full_match import match
+
+from printo import describe_call, not_none
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_basic():
+    """mypy accepts the basic call signature and infers str return type."""
+    _: str = describe_call('MyClass', (1, 2, 'text'), {'key': 1})
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_with_list_args():
+    """mypy accepts a list for the args parameter, not only tuple."""
+    _: str = describe_call('MyClass', [1, 2, 'text'], {'key': 1})
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_with_filters():
+    """mypy accepts a filters dict with int and str keys and callable values."""
+    _: str = describe_call('MyClass', (1, 2), {'key': 1}, filters={1: lambda x: x != 2, 'key': lambda _: True})
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_with_not_none_filter():
+    """mypy accepts not_none as a valid filter value."""
+    _: str = describe_call('MyClass', (1, None), {}, filters={1: not_none})
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_with_serializer():
+    """mypy accepts a Callable[[Any], str] for the serializer parameter."""
+    _: str = describe_call('MyClass', (1, 2), {'key': 'val'}, serializer=lambda x: repr(x).upper())
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_with_placeholders():
+    """mypy accepts a placeholders dict with str and int keys and str values."""
+    _: str = describe_call('MyClass', (1, 2), {'password': 'secret'}, placeholders={0: '***', 'password': '***'})
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_with_item_limit():
+    """mypy accepts an int for the item_limit parameter."""
+    _: str = describe_call('MyClass', (123456789,), {'name': 'a very long string'}, item_limit=5)
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_with_total_limit():
+    """mypy accepts an int for the total_limit parameter."""
+    _: str = describe_call('MyClass', (), {'a': 1, 'b': 2, 'c': 3}, total_limit=20)
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_invalid_class_name_type():
+    """mypy rejects int as class_name — expected str."""
+    describe_call(42, [], {})  # E: [arg-type]
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_invalid_args_type():
+    """mypy rejects dict as args — expected Tuple or List."""
+    describe_call('MyClass', {}, {})  # E: [arg-type]
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_invalid_kwargs_key_type():
+    """mypy rejects int as a kwargs key — expected str."""
+    describe_call('MyClass', (), {1: 'val'})  # E: [dict-item]
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_invalid_kwargs_type():
+    """mypy rejects list as kwargs — expected Dict[str, Any]."""
+    with pytest.raises(AttributeError, match=match("'list' object has no attribute 'items'")):
+        describe_call('MyClass', [], [])  # E: [arg-type]
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_invalid_serializer_type():
+    """mypy rejects int as serializer — expected Callable[[Any], str]."""
+    with pytest.raises(ValueError, match=match('It is impossible to determine the signature of an object that is not being callable.')):
+        describe_call('MyClass', [], {}, serializer=42)  # E: [arg-type]
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_invalid_filters_key_type():
+    """mypy rejects float as a filters key — expected str or int."""
+    describe_call('MyClass', [], {}, filters={1.5: not_none})  # E: [dict-item]
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_invalid_filters_value_type():
+    """mypy rejects int as a filters value — expected Callable[[Any], bool]."""
+    describe_call('MyClass', [], {}, filters={'x': 42})  # E: [dict-item]
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_invalid_placeholders_key_type():
+    """mypy rejects float as a placeholders key — expected str or int."""
+    describe_call('MyClass', [], {}, placeholders={1.5: '***'})  # E: [dict-item]
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_invalid_placeholders_value_type():
+    """mypy rejects int as a placeholders value — expected str."""
+    describe_call('MyClass', [], {}, placeholders={'x': 42})  # E: [dict-item]
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_invalid_item_limit_type():
+    """mypy rejects str as item_limit — expected int."""
+    with pytest.raises(TypeError, match=match("'<' not supported between instances of 'str' and 'int'")):
+        describe_call('MyClass', [], {}, item_limit='5')  # E: [arg-type]
+
+
+@pytest.mark.mypy_testing
+def test_describe_call_invalid_total_limit_type():
+    """mypy rejects str as total_limit — expected int."""
+    with pytest.raises(TypeError, match=match("'<' not supported between instances of 'str' and 'int'")):
+        describe_call('MyClass', [], {}, total_limit='15')  # E: [arg-type]

tests/typing/test_describe_call.py

@@ -0,0 +1,224 @@
+import pytest
+from full_match import match
+from sigmatch import SignatureMismatchError
+
+from printo import repred
+from printo.filters import not_none
+
+
+@pytest.mark.mypy_testing
+def test_repred_bare_decorator():
+    """mypy infers the exact decorated class type, not Any or object."""
+    @repred
+    class Foo:
+        def __init__(self, x: int) -> None:
+            self.x = x
+
+    _: Foo = Foo(1)
+
+
+@pytest.mark.mypy_testing
+def test_repred_empty_parens():
+    """mypy infers the exact decorated class type when @repred() is called with empty parens."""
+    @repred()
+    class Foo:
+        def __init__(self, x: int) -> None:
+            self.x = x
+
+    _: Foo = Foo(1)
+
+
+@pytest.mark.mypy_testing
+def test_repred_with_prefer_positional():
+    """mypy infers the exact decorated class type when prefer_positional=True is passed."""
+    @repred(prefer_positional=True)
+    class Foo:
+        def __init__(self, x: int) -> None:
+            self.x = x
+
+    _: Foo = Foo(1)
+
+
+@pytest.mark.mypy_testing
+def test_repred_with_qualname():
+    """mypy infers the exact decorated class type when qualname=True is passed."""
+    @repred(qualname=True)
+    class Foo:
+        def __init__(self, x: int) -> None:
+            self.x = x
+
+    _: Foo = Foo(1)
+
+
+@pytest.mark.mypy_testing
+def test_repred_with_ignore():
+    """mypy infers the exact decorated class type when ignore=[...] is passed."""
+    @repred(ignore=['x'])
+    class Foo:
+        def __init__(self, x: int, y: int) -> None:
+            self.x = x
+            self.y = y
+
+    _: Foo = Foo(1, 2)
+
+
+@pytest.mark.mypy_testing
+def test_repred_with_getters():
+    """mypy infers the exact decorated class type when getters={...} is passed."""
+    @repred(getters={'x': lambda self: self.x})
+    class Foo:
+        def __init__(self, x: int) -> None:
+            self.x = x
+
+    _: Foo = Foo(1)
+
+
+@pytest.mark.mypy_testing
+def test_repred_with_filters():
+    """mypy infers the exact decorated class type when filters={...} is passed."""
+    @repred(filters={'x': not_none})
+    class Foo:
+        def __init__(self, x: int) -> None:
+            self.x = x
+
+    _: Foo = Foo(1)
+
+
+@pytest.mark.mypy_testing
+def test_repred_with_positionals():
+    """mypy infers the exact decorated class type when positionals=[...] is passed."""
+    @repred(positionals=['x'])
+    class Foo:
+        def __init__(self, x: int) -> None:
+            self.x = x
+
+    _: Foo = Foo(1)
+
+
+@pytest.mark.mypy_testing
+def test_repred_with_multiple_kwargs():
+    """mypy infers the exact decorated class type when multiple keyword args are passed."""
+    @repred(prefer_positional=True, qualname=True)
+    class Foo:
+        def __init__(self, x: int) -> None:
+            self.x = x
+
+    _: Foo = Foo(1)
+
+
+@pytest.mark.mypy_testing
+def test_repred_with_varargs():
+    """mypy infers the exact decorated class type on a class with *args and **kwargs."""
+    @repred
+    class Foo:
+        def __init__(self, a: int, b: int, *args: int, **kwargs: str) -> None:
+            self.a = a
+            self.b = b
+            self.args = args
+            self.kwargs = kwargs
+
+    _: Foo = Foo(1, 2)
+
+
+@pytest.mark.mypy_testing
+def test_repred_instance_type():
+    """mypy infers Foo instance type, not object or Any, after bare @repred."""
+    @repred
+    class Foo:
+        def __init__(self, x: int) -> None:
+            self.x = x
+
+    _: Foo = Foo(1)
+
+
+@pytest.mark.mypy_testing
+def test_repred_instance_wrong_type():
+    """mypy rejects assigning a @repred-decorated class instance to an incompatible type."""
+    @repred
+    class Foo:
+        def __init__(self, x: int) -> None:
+            self.x = x
+
+    _: str = Foo(1)  # E: [assignment]
+
+
+@pytest.mark.mypy_testing
+def test_repred_instance_wrong_type_with_kwargs():
+    """mypy rejects wrong-type assignment even when @repred is called with keyword args."""
+    @repred(prefer_positional=True)
+    class Foo:
+        def __init__(self, x: int) -> None:
+            self.x = x
+
+    _: str = Foo(1)  # E: [assignment]
+
+
+@pytest.mark.mypy_testing
+def test_repred_invalid_filter_value_type():
+    """
+    mypy rejects a non-callable filters value as dict-item error.
+
+    The pytest.raises wrapper is needed because repred also validates types at runtime.
+    """
+    with pytest.raises(SignatureMismatchError, match=match('You have defined a getter for parameter "x" that cannot be called with a single argument.')):
+        @repred(filters={'x': 42})  # E: [dict-item]
+        class Foo:
+            def __init__(self, x: int) -> None:
+                self.x = x
+
+
+@pytest.mark.mypy_testing
+def test_repred_invalid_getter_value_type():
+    """
+    mypy rejects a non-callable getters value as dict-item error.
+
+    The pytest.raises wrapper is needed because repred also validates types at runtime.
+    """
+    with pytest.raises(SignatureMismatchError, match=match('You have defined a getter for parameter "x" that cannot be called with a single argument (an object of class Foo).')):
+        @repred(getters={'x': 'not_a_function'})  # E: [dict-item]
+        class Foo:
+            def __init__(self, x: int) -> None:
+                self.x = x
+
+
+@pytest.mark.mypy_testing
+def test_repred_invalid_filter_key_type():
+    """
+    mypy rejects a float filters key as dict-item error.
+
+    The pytest.raises wrapper is needed because repred also validates types at runtime.
+    """
+    with pytest.raises(ValueError, match=match('Keys for a filtered dictionary can be either integers starting from 0 or strings (parameter names).')):
+        @repred(filters={1.5: not_none})  # E: [dict-item]
+        class Foo:
+            def __init__(self, x: int) -> None:
+                self.x = x
+
+
+@pytest.mark.mypy_testing
+def test_repred_invalid_ignore_element_type():
+    """
+    mypy rejects a non-str element in the ignore list as list-item error.
+
+    The pytest.raises wrapper is needed because repred also validates types at runtime.
+    """
+    with pytest.raises(AttributeError, match=match("'int' object has no attribute 'isidentifier'")):
+        @repred(ignore=[1])  # E: [list-item]
+        class Foo:
+            def __init__(self, x: int, y: int) -> None:
+                self.x = x
+                self.y = y
+
+
+@pytest.mark.mypy_testing
+def test_repred_invalid_positionals_element_type():
+    """
+    mypy rejects a non-str element in the positionals list as list-item error.
+
+    The pytest.raises wrapper is needed because repred also validates types at runtime.
+    """
+    with pytest.raises(AttributeError, match=match("'int' object has no attribute 'isidentifier'")):
+        @repred(positionals=[1])  # E: [list-item]
+        class Foo:
+            def __init__(self, x: int) -> None:
+                self.x = x