tests: test_code: improve/clarify imports

testing/code/test_code.py

@@ -5,23 +5,26 @@
 
 import py.path
 
-import _pytest._code
 import pytest
+from _pytest._code import Code
+from _pytest._code import ExceptionInfo
+from _pytest._code import Frame
 from _pytest._code import getfslineno
+from _pytest._code.code import ReprFuncArgs
 
 
 def test_ne() -> None:
-    code1 = _pytest._code.Code(compile('foo = "bar"', "", "exec"))
+    code1 = Code(compile('foo = "bar"', "", "exec"))
     assert code1 == code1
-    code2 = _pytest._code.Code(compile('foo = "baz"', "", "exec"))
+    code2 = Code(compile('foo = "baz"', "", "exec"))
     assert code2 != code1
 
 
 def test_code_gives_back_name_for_not_existing_file() -> None:
     name = "abc-123"
     co_code = compile("pass\n", name, "exec")
     assert co_code.co_filename == name
-    code = _pytest._code.Code(co_code)
+    code = Code(co_code)
     assert str(code.path) == name
     assert code.fullsource is None
 
@@ -30,21 +33,21 @@ def test_code_with_class() -> None:
     class A:
         pass
 
-    pytest.raises(TypeError, _pytest._code.Code, A)
+    pytest.raises(TypeError, Code, A)
 
 
 def x() -> None:
     raise NotImplementedError()
 
 
 def test_code_fullsource() -> None:
-    code = _pytest._code.Code(x)
+    code = Code(x)
     full = code.fullsource
     assert "test_code_fullsource()" in str(full)
 
 
 def test_code_source() -> None:
-    code = _pytest._code.Code(x)
+    code = Code(x)
     src = code.source()
     expected = """def x() -> None:
     raise NotImplementedError()"""
@@ -55,7 +58,7 @@ def test_frame_getsourcelineno_myself() -> None:
     def func() -> FrameType:
         return sys._getframe(0)
 
-    f = _pytest._code.Frame(func())
+    f = Frame(func())
     source, lineno = f.code.fullsource, f.lineno
     assert source is not None
     assert source[lineno].startswith("        return sys._getframe(0)")
@@ -65,13 +68,13 @@ def test_getstatement_empty_fullsource() -> None:
     def func() -> FrameType:
         return sys._getframe(0)
 
-    f = _pytest._code.Frame(func())
+    f = Frame(func())
     with mock.patch.object(f.code.__class__, "fullsource", None):
         assert f.statement == ""
 
 
 def test_code_from_func() -> None:
-    co = _pytest._code.Code(test_frame_getsourcelineno_myself)
+    co = Code(test_frame_getsourcelineno_myself)
     assert co.firstlineno
     assert co.path
 
@@ -90,51 +93,51 @@ def test_code_getargs() -> None:
     def f1(x):
         raise NotImplementedError()
 
-    c1 = _pytest._code.Code(f1)
+    c1 = Code(f1)
     assert c1.getargs(var=True) == ("x",)
 
     def f2(x, *y):
         raise NotImplementedError()
 
-    c2 = _pytest._code.Code(f2)
+    c2 = Code(f2)
     assert c2.getargs(var=True) == ("x", "y")
 
     def f3(x, **z):
         raise NotImplementedError()
 
-    c3 = _pytest._code.Code(f3)
+    c3 = Code(f3)
     assert c3.getargs(var=True) == ("x", "z")
 
     def f4(x, *y, **z):
         raise NotImplementedError()
 
-    c4 = _pytest._code.Code(f4)
+    c4 = Code(f4)
     assert c4.getargs(var=True) == ("x", "y", "z")
 
 
 def test_frame_getargs() -> None:
     def f1(x) -> FrameType:
         return sys._getframe(0)
 
-    fr1 = _pytest._code.Frame(f1("a"))
+    fr1 = Frame(f1("a"))
     assert fr1.getargs(var=True) == [("x", "a")]
 
     def f2(x, *y) -> FrameType:
         return sys._getframe(0)
 
-    fr2 = _pytest._code.Frame(f2("a", "b", "c"))
+    fr2 = Frame(f2("a", "b", "c"))
     assert fr2.getargs(var=True) == [("x", "a"), ("y", ("b", "c"))]
 
     def f3(x, **z) -> FrameType:
         return sys._getframe(0)
 
-    fr3 = _pytest._code.Frame(f3("a", b="c"))
+    fr3 = Frame(f3("a", b="c"))
     assert fr3.getargs(var=True) == [("x", "a"), ("z", {"b": "c"})]
 
     def f4(x, *y, **z) -> FrameType:
         return sys._getframe(0)
 
-    fr4 = _pytest._code.Frame(f4("a", "b", c="d"))
+    fr4 = Frame(f4("a", "b", c="d"))
     assert fr4.getargs(var=True) == [("x", "a"), ("y", ("b",)), ("z", {"c": "d"})]
 
 
@@ -146,12 +149,12 @@ def test_bad_getsource(self) -> None:
             else:
                 assert False
         except AssertionError:
-            exci = _pytest._code.ExceptionInfo.from_current()
+            exci = ExceptionInfo.from_current()
         assert exci.getrepr()
 
     def test_from_current_with_missing(self) -> None:
         with pytest.raises(AssertionError, match="no current exception"):
-            _pytest._code.ExceptionInfo.from_current()
+            ExceptionInfo.from_current()
 
 
 class TestTracebackEntry:
@@ -162,7 +165,7 @@ def test_getsource(self) -> None:
             else:
                 assert False
         except AssertionError:
-            exci = _pytest._code.ExceptionInfo.from_current()
+            exci = ExceptionInfo.from_current()
         entry = exci.traceback[0]
         source = entry.getsource()
         assert source is not None
@@ -172,8 +175,6 @@ def test_getsource(self) -> None:
 
 class TestReprFuncArgs:
     def test_not_raise_exception_with_mixed_encoding(self, tw_mock) -> None:
-        from _pytest._code.code import ReprFuncArgs
-
         args = [("unicode_string", "São Paulo"), ("utf8_string", b"S\xc3\xa3o Paulo")]
 
         r = ReprFuncArgs(args)