예제 #1
0
def test_node_warn_is_no_longer_only_pytest_warnings(pytester: Pytester,
                                                     warn_type: Type[Warning],
                                                     msg: str) -> None:
    items = pytester.getitems("""
        def test():
            pass
    """)
    with pytest.warns(warn_type, match=msg):
        items[0].warn(warn_type(msg))
예제 #2
0
 def test_function_equality_with_callspec(self, pytester: Pytester) -> None:
     items = pytester.getitems("""
         import pytest
         @pytest.mark.parametrize('arg', [1,2])
         def test_function(arg):
             pass
     """)
     assert items[0] != items[1]
     assert not (items[0] == items[1])
예제 #3
0
def test_node_warning_enforces_warning_types(pytester: Pytester) -> None:
    items = pytester.getitems("""
        def test():
            pass
    """)
    with pytest.raises(
            ValueError,
            match="warning must be an instance of Warning or subclass"):
        items[0].warn(Exception("ok"))  # type: ignore[arg-type]
예제 #4
0
def test_std_warn_not_pytestwarning(pytester: Pytester) -> None:
    items = pytester.getitems(
        """
        def test():
            pass
    """
    )
    with pytest.raises(ValueError, match=".*instance of PytestWarning.*"):
        items[0].warn(UserWarning("some warning"))  # type: ignore[arg-type]
예제 #5
0
    def test_parametrize_with_empty_string_arguments(
            self, pytester: Pytester) -> None:
        items = pytester.getitems("""\
            import pytest

            @pytest.mark.parametrize('v', ('', ' '))
            @pytest.mark.parametrize('w', ('', ' '))
            def test(v, w): ...
            """)
        names = {item.name for item in items}
        assert names == {"test[-]", "test[ -]", "test[- ]", "test[ - ]"}
예제 #6
0
 def test_skipif_class(self, pytester: Pytester) -> None:
     (item, ) = pytester.getitems("""
         import pytest
         class TestClass(object):
             pytestmark = pytest.mark.skipif("config._hackxyz")
             def test_func(self):
                 pass
     """)
     item.config._hackxyz = 3  # type: ignore[attr-defined]
     skipped = evaluate_skip_marks(item)
     assert skipped
     assert skipped.reason == "condition: config._hackxyz"
예제 #7
0
def test_testcase_totally_incompatible_exception_info(
        pytester: Pytester) -> None:
    import _pytest.unittest

    (item, ) = pytester.getitems("""
        from unittest import TestCase
        class MyTestCase(TestCase):
            def test_hello(self):
                pass
    """)
    assert isinstance(item, _pytest.unittest.TestCaseFunction)
    item.addError(None, 42)  # type: ignore[arg-type]
    excinfo = item._excinfo
    assert excinfo is not None
    assert "ERROR: Unknown Incompatible" in str(excinfo.pop(0).getrepr())
예제 #8
0
 def test_parametrize_with_mark(self, pytester: Pytester) -> None:
     items = pytester.getitems("""
         import pytest
         @pytest.mark.foo
         @pytest.mark.parametrize('arg', [
             1,
             pytest.param(2, marks=[pytest.mark.baz, pytest.mark.bar])
         ])
         def test_function(arg):
             pass
     """)
     keywords = [item.keywords for item in items]
     assert ("foo" in keywords[0] and "bar" not in keywords[0]
             and "baz" not in keywords[0])
     assert "foo" in keywords[1] and "bar" in keywords[
         1] and "baz" in keywords[1]
예제 #9
0
    def test_function_originalname(self, pytester: Pytester) -> None:
        items = pytester.getitems("""
            import pytest

            @pytest.mark.parametrize('arg', [1,2])
            def test_func(arg):
                pass

            def test_no_param():
                pass
        """)
        originalnames = []
        for x in items:
            assert isinstance(x, pytest.Function)
            originalnames.append(x.originalname)
        assert originalnames == [
            "test_func",
            "test_func",
            "test_no_param",
        ]
예제 #10
0
def test_function_instance(pytester: Pytester) -> None:
    items = pytester.getitems(
        """
        def test_func(): pass
        class TestIt:
            def test_method(self): pass
            @classmethod
            def test_class(cls): pass
            @staticmethod
            def test_static(): pass
        """
    )
    assert len(items) == 3
    assert isinstance(items[0], Function)
    assert items[0].name == "test_func"
    assert items[0].instance is None
    assert isinstance(items[1], Function)
    assert items[1].name == "test_method"
    assert items[1].instance is not None
    assert items[1].instance.__class__.__name__ == "TestIt"
    assert isinstance(items[2], Function)
    assert items[2].name == "test_static"
    assert items[2].instance is None