| # Test cases for imports and related features (compile and run) |
| |
| [case testImports] |
| import testmodule |
| |
| def f(x: int) -> int: |
| return testmodule.factorial(5) |
| |
| def g(x: int) -> int: |
| from welp import foo |
| return foo(x) |
| |
| def test_import_basics() -> None: |
| assert f(5) == 120 |
| assert g(5) == 5 |
| |
| def test_import_submodule_within_function() -> None: |
| import pkg.mod |
| assert pkg.x == 1 |
| assert pkg.mod.y == 2 |
| |
| def test_import_as_submodule_within_function() -> None: |
| import pkg.mod as mm |
| assert mm.y == 2 |
| |
| # TODO: Don't add local imports to globals() |
| # |
| # def test_local_import_not_in_globals() -> None: |
| # import nob |
| # assert 'nob' not in globals() |
| |
| def test_import_module_without_stub_in_function() -> None: |
| # 'psutil' must not have a stub in typeshed for this test case |
| import psutil # type: ignore |
| # TODO: We shouldn't add local imports to globals() |
| # assert 'psutil' not in globals() |
| assert isinstance(psutil.__name__, str) |
| |
| def test_import_as_module_without_stub_in_function() -> None: |
| # 'psutil' must not have a stub in typeshed for this test case |
| import psutil as pp # type: ignore |
| assert 'psutil' not in globals() |
| # TODO: We shouldn't add local imports to globals() |
| # assert 'pp' not in globals() |
| assert isinstance(pp.__name__, str) |
| |
| [file testmodule.py] |
| def factorial(x: int) -> int: |
| if x == 0: |
| return 1 |
| else: |
| return x * factorial(x-1) |
| [file welp.py] |
| def foo(x: int) -> int: |
| return x |
| [file pkg/__init__.py] |
| x = 1 |
| [file pkg/mod.py] |
| y = 2 |
| [file nob.py] |
| z = 3 |
| |
| [case testImportMissing] |
| # The unchecked module is configured by the test harness to not be |
| # picked up by mypy, so we can test that we do that right thing when |
| # calling library modules without stubs. |
| import unchecked # type: ignore |
| import unchecked as lol # type: ignore |
| assert unchecked.x == 10 |
| assert lol.x == 10 |
| [file unchecked.py] |
| x = 10 |
| |
| [file driver.py] |
| import native |
| |
| [case testFromImport] |
| from testmodule import g |
| |
| def f(x: int) -> int: |
| return g(x) |
| [file testmodule.py] |
| def g(x: int) -> int: |
| return x + 1 |
| [file driver.py] |
| from native import f |
| assert f(1) == 2 |
| |
| [case testFromImportWithUntypedModule] |
| |
| # avoid including an __init__.py and use type: ignore to test what happens |
| # if mypy can't tell if mod isn't a module |
| from pkg import mod # type: ignore |
| |
| def test_import() -> None: |
| assert mod.h(8) == 24 |
| |
| [file pkg/mod.py] |
| def h(x): |
| return x * 3 |
| |
| [case testFromImportWithKnownModule] |
| from pkg import mod1 |
| from pkg import mod2 as modmod |
| from pkg.mod2 import g as gg |
| from pkg.mod3 import h as h2, g as g2 |
| |
| def test_import() -> None: |
| assert mod1.h(8) == 24 |
| assert modmod.g(1) == 1 |
| assert gg(2) == 2 |
| assert h2(10) == 12 |
| assert g2(10) == 13 |
| |
| [file pkg/__init__.py] |
| [file pkg/mod1.py] |
| def h(x: int) -> int: |
| return x * 3 |
| |
| [file pkg/mod2.py] |
| def g(x: int) -> int: |
| return x |
| |
| [file pkg/mod3.py] |
| def h(x: int) -> int: |
| return x + 2 |
| |
| def g(x: int) -> int: |
| return x + 3 |
| |
| [case testFromImportWithUnKnownModule] |
| def test_import() -> None: |
| try: |
| from pkg import a # type: ignore |
| except ImportError: |
| pass |
| |
| [file pkg/__init__.py] |
| |
| [case testMultipleFromImportsWithSamePackageButDifferentModules] |
| from pkg import a |
| from pkg import b |
| |
| def test_import() -> None: |
| assert a.g() == 4 |
| assert b.h() == 39 |
| |
| [file pkg/__init__.py] |
| [file pkg/a.py] |
| |
| def g() -> int: |
| return 4 |
| |
| [file pkg/b.py] |
| |
| def h() -> int: |
| return 39 |
| |
| [case testReexport] |
| # Test that we properly handle accessing values that have been reexported |
| import a |
| def f(x: int) -> int: |
| return a.g(x) + a.foo + a.b.foo |
| |
| whatever = a.A() |
| |
| [file a.py] |
| from b import g as g, A as A, foo as foo |
| import b |
| |
| [file b.py] |
| def g(x: int) -> int: |
| return x + 1 |
| |
| class A: |
| pass |
| |
| foo = 20 |
| |
| [file driver.py] |
| from native import f, whatever |
| import b |
| |
| assert f(20) == 61 |
| assert isinstance(whatever, b.A) |
| |
| [case testAssignModule] |
| import a |
| assert a.x == 20 |
| a.x = 10 |
| [file a.py] |
| x = 20 |
| [file driver.py] |
| import native |