From 47ff911c8ff3e705ead23b183530ad161a6261ba Mon Sep 17 00:00:00 2001 From: Christine Mecklenborg Date: Thu, 29 Oct 2020 20:39:44 -0500 Subject: [PATCH] Migrate test_assertion.py from testdir to pytester --- testing/test_assertion.py | 343 ++++++++++++++++++++------------------ 1 file changed, 178 insertions(+), 165 deletions(-) diff --git a/testing/test_assertion.py b/testing/test_assertion.py index e3b6fa519..02ecaf125 100644 --- a/testing/test_assertion.py +++ b/testing/test_assertion.py @@ -12,6 +12,7 @@ import pytest from _pytest import outcomes from _pytest.assertion import truncate from _pytest.assertion import util +from _pytest.pytester import Pytester def mock_config(verbose=0): @@ -27,9 +28,12 @@ def mock_config(verbose=0): class TestImportHookInstallation: @pytest.mark.parametrize("initial_conftest", [True, False]) @pytest.mark.parametrize("mode", ["plain", "rewrite"]) - def test_conftest_assertion_rewrite(self, testdir, initial_conftest, mode): + def test_conftest_assertion_rewrite( + self, pytester: Pytester, initial_conftest, mode + ) -> None: """Test that conftest files are using assertion rewrite on import (#1619).""" - testdir.tmpdir.join("foo/tests").ensure(dir=1) + pytester.mkdir("foo") + pytester.mkdir("foo/tests") conftest_path = "conftest.py" if initial_conftest else "foo/conftest.py" contents = { conftest_path: """ @@ -45,8 +49,8 @@ class TestImportHookInstallation: check_first([10, 30], 30) """, } - testdir.makepyfile(**contents) - result = testdir.runpytest_subprocess("--assert=%s" % mode) + pytester.makepyfile(**contents) + result = pytester.runpytest_subprocess("--assert=%s" % mode) if mode == "plain": expected = "E AssertionError" elif mode == "rewrite": @@ -55,21 +59,21 @@ class TestImportHookInstallation: assert 0 result.stdout.fnmatch_lines([expected]) - def test_rewrite_assertions_pytester_plugin(self, testdir): + def test_rewrite_assertions_pytester_plugin(self, pytester: Pytester) -> None: """ Assertions in the pytester plugin must also benefit from assertion rewriting (#1920). """ - testdir.makepyfile( + pytester.makepyfile( """ pytest_plugins = ['pytester'] - def test_dummy_failure(testdir): # how meta! - testdir.makepyfile('def test(): assert 0') - r = testdir.inline_run() + def test_dummy_failure(pytester): # how meta! + pytester.makepyfile('def test(): assert 0') + r = pytester.inline_run() r.assertoutcome(passed=1) """ ) - result = testdir.runpytest_subprocess() + result = pytester.runpytest_subprocess() result.stdout.fnmatch_lines( [ "> r.assertoutcome(passed=1)", @@ -89,7 +93,7 @@ class TestImportHookInstallation: ) @pytest.mark.parametrize("mode", ["plain", "rewrite"]) - def test_pytest_plugins_rewrite(self, testdir, mode): + def test_pytest_plugins_rewrite(self, pytester: Pytester, mode) -> None: contents = { "conftest.py": """ pytest_plugins = ['ham'] @@ -107,8 +111,8 @@ class TestImportHookInstallation: check_first([10, 30], 30) """, } - testdir.makepyfile(**contents) - result = testdir.runpytest_subprocess("--assert=%s" % mode) + pytester.makepyfile(**contents) + result = pytester.runpytest_subprocess("--assert=%s" % mode) if mode == "plain": expected = "E AssertionError" elif mode == "rewrite": @@ -118,7 +122,9 @@ class TestImportHookInstallation: result.stdout.fnmatch_lines([expected]) @pytest.mark.parametrize("mode", ["str", "list"]) - def test_pytest_plugins_rewrite_module_names(self, testdir, mode): + def test_pytest_plugins_rewrite_module_names( + self, pytester: Pytester, mode + ) -> None: """Test that pluginmanager correct marks pytest_plugins variables for assertion rewriting if they are defined as plain strings or list of strings (#1888). @@ -138,11 +144,13 @@ class TestImportHookInstallation: assert 'ham' in pytestconfig.pluginmanager.rewrite_hook._must_rewrite """, } - testdir.makepyfile(**contents) - result = testdir.runpytest_subprocess("--assert=rewrite") + pytester.makepyfile(**contents) + result = pytester.runpytest_subprocess("--assert=rewrite") assert result.ret == 0 - def test_pytest_plugins_rewrite_module_names_correctly(self, testdir): + def test_pytest_plugins_rewrite_module_names_correctly( + self, pytester: Pytester + ) -> None: """Test that we match files correctly when they are marked for rewriting (#2939).""" contents = { "conftest.py": """\ @@ -156,16 +164,18 @@ class TestImportHookInstallation: assert pytestconfig.pluginmanager.rewrite_hook.find_spec('hamster') is None """, } - testdir.makepyfile(**contents) - result = testdir.runpytest_subprocess("--assert=rewrite") + pytester.makepyfile(**contents) + result = pytester.runpytest_subprocess("--assert=rewrite") assert result.ret == 0 @pytest.mark.parametrize("mode", ["plain", "rewrite"]) - def test_installed_plugin_rewrite(self, testdir, mode, monkeypatch): + def test_installed_plugin_rewrite( + self, pytester: Pytester, mode, monkeypatch + ) -> None: monkeypatch.delenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", raising=False) # Make sure the hook is installed early enough so that plugins # installed via setuptools are rewritten. - testdir.tmpdir.join("hampkg").ensure(dir=1) + pytester.mkdir("hampkg") contents = { "hampkg/__init__.py": """\ import pytest @@ -219,8 +229,8 @@ class TestImportHookInstallation: check_first([10, 30], 30) """, } - testdir.makepyfile(**contents) - result = testdir.run( + pytester.makepyfile(**contents) + result = pytester.run( sys.executable, "mainwrapper.py", "-s", "--assert=%s" % mode ) if mode == "plain": @@ -231,8 +241,8 @@ class TestImportHookInstallation: assert 0 result.stdout.fnmatch_lines([expected]) - def test_rewrite_ast(self, testdir): - testdir.tmpdir.join("pkg").ensure(dir=1) + def test_rewrite_ast(self, pytester: Pytester) -> None: + pytester.mkdir("pkg") contents = { "pkg/__init__.py": """ import pytest @@ -265,8 +275,8 @@ class TestImportHookInstallation: pkg.other.tool() """, } - testdir.makepyfile(**contents) - result = testdir.runpytest_subprocess("--assert=rewrite") + pytester.makepyfile(**contents) + result = pytester.runpytest_subprocess("--assert=rewrite") result.stdout.fnmatch_lines( [ ">*assert a == b*", @@ -285,8 +295,8 @@ class TestImportHookInstallation: class TestBinReprIntegration: - def test_pytest_assertrepr_compare_called(self, testdir): - testdir.makeconftest( + def test_pytest_assertrepr_compare_called(self, pytester: Pytester) -> None: + pytester.makeconftest( """ import pytest values = [] @@ -298,7 +308,7 @@ class TestBinReprIntegration: return values """ ) - testdir.makepyfile( + pytester.makepyfile( """ def test_hello(): assert 0 == 1 @@ -306,7 +316,7 @@ class TestBinReprIntegration: assert list == [("==", 0, 1)] """ ) - result = testdir.runpytest("-v") + result = pytester.runpytest("-v") result.stdout.fnmatch_lines(["*test_hello*FAIL*", "*test_check*PASS*"]) @@ -320,7 +330,7 @@ def callequal(left: Any, right: Any, verbose: int = 0) -> Optional[List[str]]: class TestAssert_reprcompare: - def test_different_types(self): + def test_different_types(self) -> None: assert callequal([0, 1], "foo") is None def test_summary(self) -> None: @@ -329,7 +339,7 @@ class TestAssert_reprcompare: summary = lines[0] assert len(summary) < 65 - def test_text_diff(self): + def test_text_diff(self) -> None: assert callequal("spam", "eggs") == [ "'spam' == 'eggs'", "- eggs", @@ -357,7 +367,7 @@ class TestAssert_reprcompare: assert "- eggs" in diff assert "+ spam" in diff - def test_bytes_diff_normal(self): + def test_bytes_diff_normal(self) -> None: """Check special handling for bytes diff (#5260)""" diff = callequal(b"spam", b"eggs") @@ -367,7 +377,7 @@ class TestAssert_reprcompare: "Use -v to get the full diff", ] - def test_bytes_diff_verbose(self): + def test_bytes_diff_verbose(self) -> None: """Check special handling for bytes diff (#5260)""" diff = callequal(b"spam", b"eggs", verbose=1) assert diff == [ @@ -445,7 +455,7 @@ class TestAssert_reprcompare: assert expl is not None assert len(expl) > 1 - def test_list_wrap_for_multiple_lines(self): + def test_list_wrap_for_multiple_lines(self) -> None: long_d = "d" * 80 l1 = ["a", "b", "c"] l2 = ["a", "b", "c", long_d] @@ -475,7 +485,7 @@ class TestAssert_reprcompare: " ]", ] - def test_list_wrap_for_width_rewrap_same_length(self): + def test_list_wrap_for_width_rewrap_same_length(self) -> None: long_a = "a" * 30 long_b = "b" * 30 long_c = "c" * 30 @@ -494,7 +504,7 @@ class TestAssert_reprcompare: " ]", ] - def test_list_dont_wrap_strings(self): + def test_list_dont_wrap_strings(self) -> None: long_a = "a" * 10 l1 = ["a"] + [long_a for _ in range(0, 7)] l2 = ["should not get wrapped"] @@ -517,7 +527,7 @@ class TestAssert_reprcompare: " ]", ] - def test_dict_wrap(self): + def test_dict_wrap(self) -> None: d1 = {"common": 1, "env": {"env1": 1, "env2": 2}} d2 = {"common": 1, "env": {"env1": 1}} @@ -581,7 +591,7 @@ class TestAssert_reprcompare: assert "Omitting" not in lines[1] assert lines[2] == "{'b': 1}" - def test_dict_different_items(self): + def test_dict_different_items(self) -> None: lines = callequal({"a": 0}, {"b": 1, "c": 2}, verbose=2) assert lines == [ "{'a': 0} == {'b': 1, 'c': 2}", @@ -605,7 +615,7 @@ class TestAssert_reprcompare: "+ {'b': 1, 'c': 2}", ] - def test_sequence_different_items(self): + def test_sequence_different_items(self) -> None: lines = callequal((1, 2), (3, 4, 5), verbose=2) assert lines == [ "(1, 2) == (3, 4, 5)", @@ -714,7 +724,7 @@ class TestAssert_reprcompare: " Probably an object has a faulty __repr__.)", ] - def test_one_repr_empty(self): + def test_one_repr_empty(self) -> None: """The faulty empty string repr did trigger an unbound local error in _diff_text.""" class A(str): @@ -729,14 +739,14 @@ class TestAssert_reprcompare: assert expl is not None assert "raised in repr()" not in " ".join(expl) - def test_unicode(self): + def test_unicode(self) -> None: assert callequal("£€", "£") == [ "'£€' == '£'", "- £", "+ £€", ] - def test_nonascii_text(self): + def test_nonascii_text(self) -> None: """ :issue: 877 non ascii python2 str caused a UnicodeDecodeError @@ -749,7 +759,7 @@ class TestAssert_reprcompare: expl = callequal(A(), "1") assert expl == ["ÿ == '1'", "- 1"] - def test_format_nonascii_explanation(self): + def test_format_nonascii_explanation(self) -> None: assert util.format_explanation("λ") def test_mojibake(self) -> None: @@ -766,9 +776,9 @@ class TestAssert_reprcompare: class TestAssert_reprcompare_dataclass: @pytest.mark.skipif(sys.version_info < (3, 7), reason="Dataclasses in Python3.7+") - def test_dataclasses(self, testdir): - p = testdir.copy_example("dataclasses/test_compare_dataclasses.py") - result = testdir.runpytest(p) + def test_dataclasses(self, pytester: Pytester) -> None: + p = pytester.copy_example("dataclasses/test_compare_dataclasses.py") + result = pytester.runpytest(p) result.assert_outcomes(failed=1, passed=0) result.stdout.fnmatch_lines( [ @@ -785,9 +795,9 @@ class TestAssert_reprcompare_dataclass: ) @pytest.mark.skipif(sys.version_info < (3, 7), reason="Dataclasses in Python3.7+") - def test_recursive_dataclasses(self, testdir): - p = testdir.copy_example("dataclasses/test_compare_recursive_dataclasses.py") - result = testdir.runpytest(p) + def test_recursive_dataclasses(self, pytester: Pytester) -> None: + p = pytester.copy_example("dataclasses/test_compare_recursive_dataclasses.py") + result = pytester.runpytest(p) result.assert_outcomes(failed=1, passed=0) result.stdout.fnmatch_lines( [ @@ -804,9 +814,9 @@ class TestAssert_reprcompare_dataclass: ) @pytest.mark.skipif(sys.version_info < (3, 7), reason="Dataclasses in Python3.7+") - def test_recursive_dataclasses_verbose(self, testdir): - p = testdir.copy_example("dataclasses/test_compare_recursive_dataclasses.py") - result = testdir.runpytest(p, "-vv") + def test_recursive_dataclasses_verbose(self, pytester: Pytester) -> None: + p = pytester.copy_example("dataclasses/test_compare_recursive_dataclasses.py") + result = pytester.runpytest(p, "-vv") result.assert_outcomes(failed=1, passed=0) result.stdout.fnmatch_lines( [ @@ -837,9 +847,9 @@ class TestAssert_reprcompare_dataclass: ) @pytest.mark.skipif(sys.version_info < (3, 7), reason="Dataclasses in Python3.7+") - def test_dataclasses_verbose(self, testdir): - p = testdir.copy_example("dataclasses/test_compare_dataclasses_verbose.py") - result = testdir.runpytest(p, "-vv") + def test_dataclasses_verbose(self, pytester: Pytester) -> None: + p = pytester.copy_example("dataclasses/test_compare_dataclasses_verbose.py") + result = pytester.runpytest(p, "-vv") result.assert_outcomes(failed=1, passed=0) result.stdout.fnmatch_lines( [ @@ -851,19 +861,21 @@ class TestAssert_reprcompare_dataclass: ) @pytest.mark.skipif(sys.version_info < (3, 7), reason="Dataclasses in Python3.7+") - def test_dataclasses_with_attribute_comparison_off(self, testdir): - p = testdir.copy_example( + def test_dataclasses_with_attribute_comparison_off( + self, pytester: Pytester + ) -> None: + p = pytester.copy_example( "dataclasses/test_compare_dataclasses_field_comparison_off.py" ) - result = testdir.runpytest(p, "-vv") + result = pytester.runpytest(p, "-vv") result.assert_outcomes(failed=0, passed=1) @pytest.mark.skipif(sys.version_info < (3, 7), reason="Dataclasses in Python3.7+") - def test_comparing_two_different_data_classes(self, testdir): - p = testdir.copy_example( + def test_comparing_two_different_data_classes(self, pytester: Pytester) -> None: + p = pytester.copy_example( "dataclasses/test_compare_two_different_dataclasses.py" ) - result = testdir.runpytest(p, "-vv") + result = pytester.runpytest(p, "-vv") result.assert_outcomes(failed=0, passed=1) @@ -939,7 +951,7 @@ class TestAssert_reprcompare_attrsclass: assert "Omitting" not in lines[2] assert lines[3] == "['field_a']" - def test_attrs_with_attribute_comparison_off(self): + def test_attrs_with_attribute_comparison_off(self) -> None: @attr.s class SimpleDataObject: field_a = attr.ib() @@ -957,7 +969,7 @@ class TestAssert_reprcompare_attrsclass: for line in lines[3:]: assert "field_b" not in line - def test_comparing_two_different_attrs_classes(self): + def test_comparing_two_different_attrs_classes(self) -> None: @attr.s class SimpleDataObjectOne: field_a = attr.ib() @@ -976,48 +988,48 @@ class TestAssert_reprcompare_attrsclass: class TestFormatExplanation: - def test_special_chars_full(self, testdir): + def test_special_chars_full(self, pytester: Pytester) -> None: # Issue 453, for the bug this would raise IndexError - testdir.makepyfile( + pytester.makepyfile( """ def test_foo(): assert '\\n}' == '' """ ) - result = testdir.runpytest() + result = pytester.runpytest() assert result.ret == 1 result.stdout.fnmatch_lines(["*AssertionError*"]) - def test_fmt_simple(self): + def test_fmt_simple(self) -> None: expl = "assert foo" assert util.format_explanation(expl) == "assert foo" - def test_fmt_where(self): + def test_fmt_where(self) -> None: expl = "\n".join(["assert 1", "{1 = foo", "} == 2"]) res = "\n".join(["assert 1 == 2", " + where 1 = foo"]) assert util.format_explanation(expl) == res - def test_fmt_and(self): + def test_fmt_and(self) -> None: expl = "\n".join(["assert 1", "{1 = foo", "} == 2", "{2 = bar", "}"]) res = "\n".join(["assert 1 == 2", " + where 1 = foo", " + and 2 = bar"]) assert util.format_explanation(expl) == res - def test_fmt_where_nested(self): + def test_fmt_where_nested(self) -> None: expl = "\n".join(["assert 1", "{1 = foo", "{foo = bar", "}", "} == 2"]) res = "\n".join(["assert 1 == 2", " + where 1 = foo", " + where foo = bar"]) assert util.format_explanation(expl) == res - def test_fmt_newline(self): + def test_fmt_newline(self) -> None: expl = "\n".join(['assert "foo" == "bar"', "~- foo", "~+ bar"]) res = "\n".join(['assert "foo" == "bar"', " - foo", " + bar"]) assert util.format_explanation(expl) == res - def test_fmt_newline_escaped(self): + def test_fmt_newline_escaped(self) -> None: expl = "\n".join(["assert foo == bar", "baz"]) res = "assert foo == bar\\nbaz" assert util.format_explanation(expl) == res - def test_fmt_newline_before_where(self): + def test_fmt_newline_before_where(self) -> None: expl = "\n".join( [ "the assertion message here", @@ -1038,7 +1050,7 @@ class TestFormatExplanation: ) assert util.format_explanation(expl) == res - def test_fmt_multi_newline_before_where(self): + def test_fmt_multi_newline_before_where(self) -> None: expl = "\n".join( [ "the assertion", @@ -1072,12 +1084,12 @@ class TestTruncateExplanation: result = truncate._truncate_explanation(expl, max_lines=8, max_chars=100) assert result == expl - def test_doesnt_truncate_at_when_input_is_5_lines_and_LT_max_chars(self): + def test_doesnt_truncate_at_when_input_is_5_lines_and_LT_max_chars(self) -> None: expl = ["a" * 100 for x in range(5)] result = truncate._truncate_explanation(expl, max_lines=8, max_chars=8 * 80) assert result == expl - def test_truncates_at_8_lines_when_given_list_of_empty_strings(self): + def test_truncates_at_8_lines_when_given_list_of_empty_strings(self) -> None: expl = ["" for x in range(50)] result = truncate._truncate_explanation(expl, max_lines=8, max_chars=100) assert result != expl @@ -1087,7 +1099,7 @@ class TestTruncateExplanation: last_line_before_trunc_msg = result[-self.LINES_IN_TRUNCATION_MSG - 1] assert last_line_before_trunc_msg.endswith("...") - def test_truncates_at_8_lines_when_first_8_lines_are_LT_max_chars(self): + def test_truncates_at_8_lines_when_first_8_lines_are_LT_max_chars(self) -> None: expl = ["a" for x in range(100)] result = truncate._truncate_explanation(expl, max_lines=8, max_chars=8 * 80) assert result != expl @@ -1097,7 +1109,7 @@ class TestTruncateExplanation: last_line_before_trunc_msg = result[-self.LINES_IN_TRUNCATION_MSG - 1] assert last_line_before_trunc_msg.endswith("...") - def test_truncates_at_8_lines_when_first_8_lines_are_EQ_max_chars(self): + def test_truncates_at_8_lines_when_first_8_lines_are_EQ_max_chars(self) -> None: expl = ["a" * 80 for x in range(16)] result = truncate._truncate_explanation(expl, max_lines=8, max_chars=8 * 80) assert result != expl @@ -1107,7 +1119,7 @@ class TestTruncateExplanation: last_line_before_trunc_msg = result[-self.LINES_IN_TRUNCATION_MSG - 1] assert last_line_before_trunc_msg.endswith("...") - def test_truncates_at_4_lines_when_first_4_lines_are_GT_max_chars(self): + def test_truncates_at_4_lines_when_first_4_lines_are_GT_max_chars(self) -> None: expl = ["a" * 250 for x in range(10)] result = truncate._truncate_explanation(expl, max_lines=8, max_chars=999) assert result != expl @@ -1117,7 +1129,7 @@ class TestTruncateExplanation: last_line_before_trunc_msg = result[-self.LINES_IN_TRUNCATION_MSG - 1] assert last_line_before_trunc_msg.endswith("...") - def test_truncates_at_1_line_when_first_line_is_GT_max_chars(self): + def test_truncates_at_1_line_when_first_line_is_GT_max_chars(self) -> None: expl = ["a" * 250 for x in range(1000)] result = truncate._truncate_explanation(expl, max_lines=8, max_chars=100) assert result != expl @@ -1127,13 +1139,13 @@ class TestTruncateExplanation: last_line_before_trunc_msg = result[-self.LINES_IN_TRUNCATION_MSG - 1] assert last_line_before_trunc_msg.endswith("...") - def test_full_output_truncated(self, monkeypatch, testdir): + def test_full_output_truncated(self, monkeypatch, pytester: Pytester) -> None: """Test against full runpytest() output.""" line_count = 7 line_len = 100 expected_truncated_lines = 2 - testdir.makepyfile( + pytester.makepyfile( r""" def test_many_lines(): a = list([str(i)[0] * %d for i in range(%d)]) @@ -1146,7 +1158,7 @@ class TestTruncateExplanation: ) monkeypatch.delenv("CI", raising=False) - result = testdir.runpytest() + result = pytester.runpytest() # without -vv, truncate the message showing a few diff lines only result.stdout.fnmatch_lines( [ @@ -1157,23 +1169,23 @@ class TestTruncateExplanation: ] ) - result = testdir.runpytest("-vv") + result = pytester.runpytest("-vv") result.stdout.fnmatch_lines(["* 6*"]) monkeypatch.setenv("CI", "1") - result = testdir.runpytest() + result = pytester.runpytest() result.stdout.fnmatch_lines(["* 6*"]) -def test_python25_compile_issue257(testdir): - testdir.makepyfile( +def test_python25_compile_issue257(pytester: Pytester) -> None: + pytester.makepyfile( """ def test_rewritten(): assert 1 == 2 # some comment """ ) - result = testdir.runpytest() + result = pytester.runpytest() assert result.ret == 1 result.stdout.fnmatch_lines( """ @@ -1183,14 +1195,14 @@ def test_python25_compile_issue257(testdir): ) -def test_rewritten(testdir): - testdir.makepyfile( +def test_rewritten(pytester: Pytester) -> None: + pytester.makepyfile( """ def test_rewritten(): assert "@py_builtins" in globals() """ ) - assert testdir.runpytest().ret == 0 + assert pytester.runpytest().ret == 0 def test_reprcompare_notin() -> None: @@ -1202,7 +1214,7 @@ def test_reprcompare_notin() -> None: ] -def test_reprcompare_whitespaces(): +def test_reprcompare_whitespaces() -> None: assert callequal("\r\n", "\n") == [ r"'\r\n' == '\n'", r"Strings contain only whitespace, escaping them using repr()", @@ -1212,8 +1224,8 @@ def test_reprcompare_whitespaces(): ] -def test_pytest_assertrepr_compare_integration(testdir): - testdir.makepyfile( +def test_pytest_assertrepr_compare_integration(pytester: Pytester) -> None: + pytester.makepyfile( """ def test_hello(): x = set(range(100)) @@ -1222,7 +1234,7 @@ def test_pytest_assertrepr_compare_integration(testdir): assert x == y """ ) - result = testdir.runpytest() + result = pytester.runpytest() result.stdout.fnmatch_lines( [ "*def test_hello():*", @@ -1234,8 +1246,8 @@ def test_pytest_assertrepr_compare_integration(testdir): ) -def test_sequence_comparison_uses_repr(testdir): - testdir.makepyfile( +def test_sequence_comparison_uses_repr(pytester: Pytester) -> None: + pytester.makepyfile( """ def test_hello(): x = set("hello x") @@ -1243,7 +1255,7 @@ def test_sequence_comparison_uses_repr(testdir): assert x == y """ ) - result = testdir.runpytest() + result = pytester.runpytest() result.stdout.fnmatch_lines( [ "*def test_hello():*", @@ -1256,19 +1268,20 @@ def test_sequence_comparison_uses_repr(testdir): ) -def test_assertrepr_loaded_per_dir(testdir): - testdir.makepyfile(test_base=["def test_base(): assert 1 == 2"]) - a = testdir.mkdir("a") - a_test = a.join("test_a.py") - a_test.write("def test_a(): assert 1 == 2") - a_conftest = a.join("conftest.py") - a_conftest.write('def pytest_assertrepr_compare(): return ["summary a"]') - b = testdir.mkdir("b") - b_test = b.join("test_b.py") - b_test.write("def test_b(): assert 1 == 2") - b_conftest = b.join("conftest.py") - b_conftest.write('def pytest_assertrepr_compare(): return ["summary b"]') - result = testdir.runpytest() +def test_assertrepr_loaded_per_dir(pytester: Pytester) -> None: + pytester.makepyfile(test_base=["def test_base(): assert 1 == 2"]) + a = pytester.mkdir("a") + a.joinpath("test_a.py").write_text("def test_a(): assert 1 == 2") + a.joinpath("conftest.py").write_text( + 'def pytest_assertrepr_compare(): return ["summary a"]' + ) + b = pytester.mkdir("b") + b.joinpath("test_b.py").write_text("def test_b(): assert 1 == 2") + b.joinpath("conftest.py").write_text( + 'def pytest_assertrepr_compare(): return ["summary b"]' + ) + + result = pytester.runpytest() result.stdout.fnmatch_lines( [ "*def test_base():*", @@ -1281,34 +1294,34 @@ def test_assertrepr_loaded_per_dir(testdir): ) -def test_assertion_options(testdir): - testdir.makepyfile( +def test_assertion_options(pytester: Pytester) -> None: + pytester.makepyfile( """ def test_hello(): x = 3 assert x == 4 """ ) - result = testdir.runpytest() + result = pytester.runpytest() assert "3 == 4" in result.stdout.str() - result = testdir.runpytest_subprocess("--assert=plain") + result = pytester.runpytest_subprocess("--assert=plain") result.stdout.no_fnmatch_line("*3 == 4*") -def test_triple_quoted_string_issue113(testdir): - testdir.makepyfile( +def test_triple_quoted_string_issue113(pytester: Pytester) -> None: + pytester.makepyfile( """ def test_hello(): assert "" == ''' '''""" ) - result = testdir.runpytest("--fulltrace") + result = pytester.runpytest("--fulltrace") result.stdout.fnmatch_lines(["*1 failed*"]) result.stdout.no_fnmatch_line("*SyntaxError*") -def test_traceback_failure(testdir): - p1 = testdir.makepyfile( +def test_traceback_failure(pytester: Pytester) -> None: + p1 = pytester.makepyfile( """ def g(): return 2 @@ -1318,7 +1331,7 @@ def test_traceback_failure(testdir): f(3) """ ) - result = testdir.runpytest(p1, "--tb=long") + result = pytester.runpytest(p1, "--tb=long") result.stdout.fnmatch_lines( [ "*test_traceback_failure.py F*", @@ -1340,7 +1353,7 @@ def test_traceback_failure(testdir): ] ) - result = testdir.runpytest(p1) # "auto" + result = pytester.runpytest(p1) # "auto" result.stdout.fnmatch_lines( [ "*test_traceback_failure.py F*", @@ -1362,9 +1375,9 @@ def test_traceback_failure(testdir): ) -def test_exception_handling_no_traceback(testdir): +def test_exception_handling_no_traceback(pytester: Pytester) -> None: """Handle chain exceptions in tasks submitted by the multiprocess module (#1984).""" - p1 = testdir.makepyfile( + p1 = pytester.makepyfile( """ from multiprocessing import Pool @@ -1380,8 +1393,8 @@ def test_exception_handling_no_traceback(testdir): multitask_job() """ ) - testdir.syspathinsert() - result = testdir.runpytest(p1, "--tb=long") + pytester.syspathinsert() + result = pytester.runpytest(p1, "--tb=long") result.stdout.fnmatch_lines( [ "====* FAILURES *====", @@ -1419,27 +1432,27 @@ def test_exception_handling_no_traceback(testdir): ), ], ) -def test_warn_missing(testdir, cmdline_args, warning_output): - testdir.makepyfile("") +def test_warn_missing(pytester: Pytester, cmdline_args, warning_output) -> None: + pytester.makepyfile("") - result = testdir.run(sys.executable, *cmdline_args) + result = pytester.run(sys.executable, *cmdline_args) result.stdout.fnmatch_lines(warning_output) -def test_recursion_source_decode(testdir): - testdir.makepyfile( +def test_recursion_source_decode(pytester: Pytester) -> None: + pytester.makepyfile( """ def test_something(): pass """ ) - testdir.makeini( + pytester.makeini( """ [pytest] python_files = *.py """ ) - result = testdir.runpytest("--collect-only") + result = pytester.runpytest("--collect-only") result.stdout.fnmatch_lines( """ @@ -1447,15 +1460,15 @@ def test_recursion_source_decode(testdir): ) -def test_AssertionError_message(testdir): - testdir.makepyfile( +def test_AssertionError_message(pytester: Pytester) -> None: + pytester.makepyfile( """ def test_hello(): x,y = 1,2 assert 0, (x,y) """ ) - result = testdir.runpytest() + result = pytester.runpytest() result.stdout.fnmatch_lines( """ *def test_hello* @@ -1465,15 +1478,15 @@ def test_AssertionError_message(testdir): ) -def test_diff_newline_at_end(testdir): - testdir.makepyfile( +def test_diff_newline_at_end(pytester: Pytester) -> None: + pytester.makepyfile( r""" def test_diff(): assert 'asdf' == 'asdf\n' """ ) - result = testdir.runpytest() + result = pytester.runpytest() result.stdout.fnmatch_lines( r""" *assert 'asdf' == 'asdf\n' @@ -1485,67 +1498,67 @@ def test_diff_newline_at_end(testdir): @pytest.mark.filterwarnings("default") -def test_assert_tuple_warning(testdir): +def test_assert_tuple_warning(pytester: Pytester) -> None: msg = "assertion is always true" - testdir.makepyfile( + pytester.makepyfile( """ def test_tuple(): assert(False, 'you shall not pass') """ ) - result = testdir.runpytest() + result = pytester.runpytest() result.stdout.fnmatch_lines([f"*test_assert_tuple_warning.py:2:*{msg}*"]) # tuples with size != 2 should not trigger the warning - testdir.makepyfile( + pytester.makepyfile( """ def test_tuple(): assert () """ ) - result = testdir.runpytest() + result = pytester.runpytest() assert msg not in result.stdout.str() -def test_assert_indirect_tuple_no_warning(testdir): - testdir.makepyfile( +def test_assert_indirect_tuple_no_warning(pytester: Pytester) -> None: + pytester.makepyfile( """ def test_tuple(): tpl = ('foo', 'bar') assert tpl """ ) - result = testdir.runpytest() + result = pytester.runpytest() output = "\n".join(result.stdout.lines) assert "WR1" not in output -def test_assert_with_unicode(testdir): - testdir.makepyfile( +def test_assert_with_unicode(pytester: Pytester) -> None: + pytester.makepyfile( """\ def test_unicode(): assert '유니코드' == 'Unicode' """ ) - result = testdir.runpytest() + result = pytester.runpytest() result.stdout.fnmatch_lines(["*AssertionError*"]) -def test_raise_unprintable_assertion_error(testdir): - testdir.makepyfile( +def test_raise_unprintable_assertion_error(pytester: Pytester) -> None: + pytester.makepyfile( r""" def test_raise_assertion_error(): raise AssertionError('\xff') """ ) - result = testdir.runpytest() + result = pytester.runpytest() result.stdout.fnmatch_lines( [r"> raise AssertionError('\xff')", "E AssertionError: *"] ) -def test_raise_assertion_error_raisin_repr(testdir): - testdir.makepyfile( +def test_raise_assertion_error_raisin_repr(pytester: Pytester) -> None: + pytester.makepyfile( """ class RaisingRepr(object): def __repr__(self): @@ -1554,14 +1567,14 @@ def test_raise_assertion_error_raisin_repr(testdir): raise AssertionError(RaisingRepr()) """ ) - result = testdir.runpytest() + result = pytester.runpytest() result.stdout.fnmatch_lines( ["E AssertionError: "] ) -def test_issue_1944(testdir): - testdir.makepyfile( +def test_issue_1944(pytester: Pytester) -> None: + pytester.makepyfile( """ def f(): return @@ -1569,7 +1582,7 @@ def test_issue_1944(testdir): assert f() == 10 """ ) - result = testdir.runpytest() + result = pytester.runpytest() result.stdout.fnmatch_lines(["*1 error*"]) assert ( "AttributeError: 'Module' object has no attribute '_obj'" @@ -1577,7 +1590,7 @@ def test_issue_1944(testdir): ) -def test_exit_from_assertrepr_compare(monkeypatch): +def test_exit_from_assertrepr_compare(monkeypatch) -> None: def raise_exit(obj): outcomes.exit("Quitting debugger") @@ -1587,16 +1600,16 @@ def test_exit_from_assertrepr_compare(monkeypatch): callequal(1, 1) -def test_assertion_location_with_coverage(testdir): +def test_assertion_location_with_coverage(pytester: Pytester) -> None: """This used to report the wrong location when run with coverage (#5754).""" - p = testdir.makepyfile( + p = pytester.makepyfile( """ def test(): assert False, 1 assert False, 2 """ ) - result = testdir.runpytest(str(p)) + result = pytester.runpytest(str(p)) result.stdout.fnmatch_lines( [ "> assert False, 1",