mypy-dev 1.9.0.dev0__py3-none-any.whl

mypy/test/testpep561.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import sys
+import tempfile
+from contextlib import contextmanager
+from typing import Iterator
+
+import filelock
+
+import mypy.api
+from mypy.test.config import package_path, pip_lock, pip_timeout, test_temp_dir
+from mypy.test.data import DataDrivenTestCase, DataSuite
+from mypy.test.helpers import assert_string_arrays_equal, perform_file_operations
+
+# NOTE: options.use_builtins_fixtures should not be set in these
+# tests, otherwise mypy will ignore installed third-party packages.
+
+
+class PEP561Suite(DataSuite):
+    files = ["pep561.test"]
+    base_path = "."
+
+    def run_case(self, test_case: DataDrivenTestCase) -> None:
+        test_pep561(test_case)
+
+
+@contextmanager
+def virtualenv(python_executable: str = sys.executable) -> Iterator[tuple[str, str]]:
+    """Context manager that creates a virtualenv in a temporary directory
+
+    Returns the path to the created Python executable
+    """
+    with tempfile.TemporaryDirectory() as venv_dir:
+        proc = subprocess.run(
+            [python_executable, "-m", "venv", venv_dir], cwd=os.getcwd(), capture_output=True
+        )
+        if proc.returncode != 0:
+            err = proc.stdout.decode("utf-8") + proc.stderr.decode("utf-8")
+            raise Exception("Failed to create venv.\n" + err)
+        if sys.platform == "win32":
+            yield venv_dir, os.path.abspath(os.path.join(venv_dir, "Scripts", "python"))
+        else:
+            yield venv_dir, os.path.abspath(os.path.join(venv_dir, "bin", "python"))
+
+
+def upgrade_pip(python_executable: str) -> None:
+    """Install pip>=21.3.1. Required for editable installs with PEP 660."""
+    if (
+        sys.version_info >= (3, 11)
+        or (3, 10, 3) <= sys.version_info < (3, 11)
+        or (3, 9, 11) <= sys.version_info < (3, 10)
+        or (3, 8, 13) <= sys.version_info < (3, 9)
+    ):
+        # Skip for more recent Python releases which come with pip>=21.3.1
+        # out of the box - for performance reasons.
+        return
+
+    install_cmd = [python_executable, "-m", "pip", "install", "pip>=21.3.1"]
+    try:
+        with filelock.FileLock(pip_lock, timeout=pip_timeout):
+            proc = subprocess.run(install_cmd, capture_output=True, env=os.environ)
+    except filelock.Timeout as err:
+        raise Exception(f"Failed to acquire {pip_lock}") from err
+    if proc.returncode != 0:
+        raise Exception(proc.stdout.decode("utf-8") + proc.stderr.decode("utf-8"))
+
+
+def install_package(
+    pkg: str, python_executable: str = sys.executable, editable: bool = False
+) -> None:
+    """Install a package from test-data/packages/pkg/"""
+    working_dir = os.path.join(package_path, pkg)
+    with tempfile.TemporaryDirectory() as dir:
+        install_cmd = [python_executable, "-m", "pip", "install"]
+        if editable:
+            install_cmd.append("-e")
+        install_cmd.append(".")
+
+        # Note that newer versions of pip (21.3+) don't
+        # follow this env variable, but this is for compatibility
+        env = {"PIP_BUILD": dir}
+        # Inherit environment for Windows
+        env.update(os.environ)
+        try:
+            with filelock.FileLock(pip_lock, timeout=pip_timeout):
+                proc = subprocess.run(install_cmd, cwd=working_dir, capture_output=True, env=env)
+        except filelock.Timeout as err:
+            raise Exception(f"Failed to acquire {pip_lock}") from err
+    if proc.returncode != 0:
+        raise Exception(proc.stdout.decode("utf-8") + proc.stderr.decode("utf-8"))
+
+
+def test_pep561(testcase: DataDrivenTestCase) -> None:
+    """Test running mypy on files that depend on PEP 561 packages."""
+    assert testcase.old_cwd is not None, "test was not properly set up"
+    python = sys.executable
+
+    assert python is not None, "Should be impossible"
+    pkgs, pip_args = parse_pkgs(testcase.input[0])
+    mypy_args = parse_mypy_args(testcase.input[1])
+    editable = False
+    for arg in pip_args:
+        if arg == "editable":
+            editable = True
+        else:
+            raise ValueError(f"Unknown pip argument: {arg}")
+    assert pkgs, "No packages to install for PEP 561 test?"
+    with virtualenv(python) as venv:
+        venv_dir, python_executable = venv
+        if editable:
+            # Editable installs with PEP 660 require pip>=21.3
+            upgrade_pip(python_executable)
+        for pkg in pkgs:
+            install_package(pkg, python_executable, editable)
+
+        cmd_line = list(mypy_args)
+        has_program = not ("-p" in cmd_line or "--package" in cmd_line)
+        if has_program:
+            program = testcase.name + ".py"
+            with open(program, "w", encoding="utf-8") as f:
+                for s in testcase.input:
+                    f.write(f"{s}\n")
+            cmd_line.append(program)
+
+        cmd_line.extend(["--no-error-summary", "--hide-error-codes"])
+        if python_executable != sys.executable:
+            cmd_line.append(f"--python-executable={python_executable}")
+
+        steps = testcase.find_steps()
+        if steps != [[]]:
+            steps = [[]] + steps
+
+        for i, operations in enumerate(steps):
+            perform_file_operations(operations)
+
+            output = []
+            # Type check the module
+            out, err, returncode = mypy.api.run(cmd_line)
+
+            # split lines, remove newlines, and remove directory of test case
+            for line in (out + err).splitlines():
+                if line.startswith(test_temp_dir + os.sep):
+                    output.append(line[len(test_temp_dir + os.sep) :].rstrip("\r\n"))
+                else:
+                    # Normalize paths so that the output is the same on Windows and Linux/macOS.
+                    line = line.replace(test_temp_dir + os.sep, test_temp_dir + "/")
+                    output.append(line.rstrip("\r\n"))
+            iter_count = "" if i == 0 else f" on iteration {i + 1}"
+            expected = testcase.output if i == 0 else testcase.output2.get(i + 1, [])
+
+            assert_string_arrays_equal(
+                expected,
+                output,
+                f"Invalid output ({testcase.file}, line {testcase.line}){iter_count}",
+            )
+
+        if has_program:
+            os.remove(program)
+
+
+def parse_pkgs(comment: str) -> tuple[list[str], list[str]]:
+    if not comment.startswith("# pkgs:"):
+        return ([], [])
+    else:
+        pkgs_str, *args = comment[7:].split(";")
+        return ([pkg.strip() for pkg in pkgs_str.split(",")], [arg.strip() for arg in args])
+
+
+def parse_mypy_args(line: str) -> list[str]:
+    m = re.match("# flags: (.*)$", line)
+    if not m:
+        return []  # No args; mypy will spit out an error.
+    return m.group(1).split()
+
+
+def test_mypy_path_is_respected() -> None:
+    assert False
+    packages = "packages"
+    pkg_name = "a"
+    with tempfile.TemporaryDirectory() as temp_dir:
+        old_dir = os.getcwd()
+        os.chdir(temp_dir)
+        try:
+            # Create the pkg for files to go into
+            full_pkg_name = os.path.join(temp_dir, packages, pkg_name)
+            os.makedirs(full_pkg_name)
+
+            # Create the empty __init__ file to declare a package
+            pkg_init_name = os.path.join(temp_dir, packages, pkg_name, "__init__.py")
+            open(pkg_init_name, "w", encoding="utf8").close()
+
+            mypy_config_path = os.path.join(temp_dir, "mypy.ini")
+            with open(mypy_config_path, "w") as mypy_file:
+                mypy_file.write("[mypy]\n")
+                mypy_file.write(f"mypy_path = ./{packages}\n")
+
+            with virtualenv() as venv:
+                venv_dir, python_executable = venv
+
+                cmd_line_args = []
+                if python_executable != sys.executable:
+                    cmd_line_args.append(f"--python-executable={python_executable}")
+                cmd_line_args.extend(["--config-file", mypy_config_path, "--package", pkg_name])
+
+                out, err, returncode = mypy.api.run(cmd_line_args)
+                assert returncode == 0
+        finally:
+            os.chdir(old_dir)

mypy/test/testpythoneval.py

@@ -0,0 +1,117 @@
+"""Test cases for running mypy programs using a Python interpreter.
+
+Each test case type checks a program then runs it using Python. The
+output (stdout) of the program is compared to expected output. Type checking
+uses full builtins and other stubs.
+
+Note: Currently Python interpreter paths are hard coded.
+
+Note: These test cases are *not* included in the main test suite, as including
+      this suite would slow down the main suite too much.
+"""
+
+from __future__ import annotations
+
+import os
+import os.path
+import re
+import subprocess
+import sys
+from tempfile import TemporaryDirectory
+
+from mypy import api
+from mypy.defaults import PYTHON3_VERSION
+from mypy.test.config import test_temp_dir
+from mypy.test.data import DataDrivenTestCase, DataSuite
+from mypy.test.helpers import assert_string_arrays_equal, split_lines
+
+# Path to Python 3 interpreter
+python3_path = sys.executable
+program_re = re.compile(r"\b_program.py\b")
+
+
+class PythonEvaluationSuite(DataSuite):
+    files = ["pythoneval.test", "pythoneval-asyncio.test"]
+    cache_dir = TemporaryDirectory()
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        test_python_evaluation(testcase, os.path.join(self.cache_dir.name, ".mypy_cache"))
+
+
+def test_python_evaluation(testcase: DataDrivenTestCase, cache_dir: str) -> None:
+    """Runs Mypy in a subprocess.
+
+    If this passes without errors, executes the script again with a given Python
+    version.
+    """
+    assert testcase.old_cwd is not None, "test was not properly set up"
+    # We must enable site packages to get access to installed stubs.
+    mypy_cmdline = [
+        "--show-traceback",
+        "--no-silence-site-packages",
+        "--no-error-summary",
+        "--hide-error-codes",
+        "--allow-empty-bodies",
+        "--force-uppercase-builtins",
+        "--test-env",  # Speeds up some checks
+    ]
+    interpreter = python3_path
+    mypy_cmdline.append(f"--python-version={'.'.join(map(str, PYTHON3_VERSION))}")
+
+    m = re.search("# flags: (.*)$", "\n".join(testcase.input), re.MULTILINE)
+    if m:
+        additional_flags = m.group(1).split()
+        for flag in additional_flags:
+            if flag.startswith("--python-version="):
+                targetted_python_version = flag.split("=")[1]
+                targetted_major, targetted_minor = targetted_python_version.split(".")
+                if (int(targetted_major), int(targetted_minor)) > (
+                    sys.version_info.major,
+                    sys.version_info.minor,
+                ):
+                    return
+        mypy_cmdline.extend(additional_flags)
+
+    # Write the program to a file.
+    program = "_" + testcase.name + ".py"
+    program_path = os.path.join(test_temp_dir, program)
+    mypy_cmdline.append(program_path)
+    with open(program_path, "w", encoding="utf8") as file:
+        for s in testcase.input:
+            file.write(f"{s}\n")
+    mypy_cmdline.append(f"--cache-dir={cache_dir}")
+    output = []
+    # Type check the program.
+    out, err, returncode = api.run(mypy_cmdline)
+    # split lines, remove newlines, and remove directory of test case
+    for line in (out + err).splitlines():
+        if line.startswith(test_temp_dir + os.sep):
+            output.append(line[len(test_temp_dir + os.sep) :].rstrip("\r\n"))
+        else:
+            # Normalize paths so that the output is the same on Windows and Linux/macOS.
+            line = line.replace(test_temp_dir + os.sep, test_temp_dir + "/")
+            output.append(line.rstrip("\r\n"))
+    if returncode > 1 and not testcase.output:
+        # Either api.run() doesn't work well in case of a crash, or pytest interferes with it.
+        # Tweak output to prevent tests with empty expected output to pass in case of a crash.
+        output.append("!!! Mypy crashed !!!")
+    if returncode == 0 and not output:
+        # Execute the program.
+        proc = subprocess.run(
+            [interpreter, "-Wignore", program], cwd=test_temp_dir, capture_output=True
+        )
+        output.extend(split_lines(proc.stdout, proc.stderr))
+    # Remove temp file.
+    os.remove(program_path)
+    for i, line in enumerate(output):
+        if os.path.sep + "typeshed" + os.path.sep in line:
+            output[i] = line.split(os.path.sep)[-1]
+    assert_string_arrays_equal(
+        adapt_output(testcase), output, f"Invalid output ({testcase.file}, line {testcase.line})"
+    )
+
+
+def adapt_output(testcase: DataDrivenTestCase) -> list[str]:
+    """Translates the generic _program.py into the actual filename."""
+    program = "_" + testcase.name + ".py"
+    return [program_re.sub(program, line) for line in testcase.output]

mypy/test/testreports.py

@@ -0,0 +1,55 @@
+"""Test cases for reports generated by mypy."""
+
+from __future__ import annotations
+
+import textwrap
+
+from mypy.report import CoberturaPackage, get_line_rate
+from mypy.test.helpers import Suite, assert_equal
+
+try:
+    import lxml  # type: ignore[import-untyped]
+except ImportError:
+    lxml = None
+
+import pytest
+
+
+class CoberturaReportSuite(Suite):
+    @pytest.mark.skipif(lxml is None, reason="Cannot import lxml. Is it installed?")
+    def test_get_line_rate(self) -> None:
+        assert_equal("1.0", get_line_rate(0, 0))
+        assert_equal("0.3333", get_line_rate(1, 3))
+
+    @pytest.mark.skipif(lxml is None, reason="Cannot import lxml. Is it installed?")
+    def test_as_xml(self) -> None:
+        import lxml.etree as etree  # type: ignore[import-untyped]
+
+        cobertura_package = CoberturaPackage("foobar")
+        cobertura_package.covered_lines = 21
+        cobertura_package.total_lines = 42
+
+        child_package = CoberturaPackage("raz")
+        child_package.covered_lines = 10
+        child_package.total_lines = 10
+        child_package.classes["class"] = etree.Element("class")
+
+        cobertura_package.packages["raz"] = child_package
+
+        expected_output = textwrap.dedent(
+            """\
+            <package complexity="1.0" name="foobar" branch-rate="0" line-rate="0.5000">
+              <classes/>
+              <packages>
+                <package complexity="1.0" name="raz" branch-rate="0" line-rate="1.0000">
+                  <classes>
+                    <class/>
+                  </classes>
+                </package>
+              </packages>
+            </package>
+        """
+        ).encode("ascii")
+        assert_equal(
+            expected_output, etree.tostring(cobertura_package.as_xml(), pretty_print=True)
+        )

mypy/test/testsemanal.py

@@ -0,0 +1,209 @@
+"""Semantic analyzer test cases"""
+
+from __future__ import annotations
+
+import sys
+from typing import Dict
+
+from mypy import build
+from mypy.defaults import PYTHON3_VERSION
+from mypy.errors import CompileError
+from mypy.modulefinder import BuildSource
+from mypy.nodes import TypeInfo
+from mypy.options import Options
+from mypy.test.config import test_temp_dir
+from mypy.test.data import DataDrivenTestCase, DataSuite
+from mypy.test.helpers import (
+    assert_string_arrays_equal,
+    find_test_files,
+    normalize_error_messages,
+    parse_options,
+    testfile_pyversion,
+)
+
+# Semantic analyzer test cases: dump parse tree
+
+# Semantic analysis test case description files.
+semanal_files = find_test_files(
+    pattern="semanal-*.test",
+    exclude=[
+        "semanal-errors-python310.test",
+        "semanal-errors.test",
+        "semanal-typeinfo.test",
+        "semanal-symtable.test",
+    ],
+)
+
+
+if sys.version_info < (3, 10):
+    semanal_files.remove("semanal-python310.test")
+
+
+def get_semanal_options(program_text: str, testcase: DataDrivenTestCase) -> Options:
+    options = parse_options(program_text, testcase, 1)
+    options.use_builtins_fixtures = True
+    options.semantic_analysis_only = True
+    options.show_traceback = True
+    options.python_version = PYTHON3_VERSION
+    options.force_uppercase_builtins = True
+    return options
+
+
+class SemAnalSuite(DataSuite):
+    files = semanal_files
+    native_sep = True
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        test_semanal(testcase)
+
+
+def test_semanal(testcase: DataDrivenTestCase) -> None:
+    """Perform a semantic analysis test case.
+
+    The testcase argument contains a description of the test case
+    (inputs and output).
+    """
+
+    try:
+        src = "\n".join(testcase.input)
+        options = get_semanal_options(src, testcase)
+        options.python_version = testfile_pyversion(testcase.file)
+        result = build.build(
+            sources=[BuildSource("main", None, src)], options=options, alt_lib_path=test_temp_dir
+        )
+        a = result.errors
+        if a:
+            raise CompileError(a)
+        # Include string representations of the source files in the actual
+        # output.
+        for module in sorted(result.files.keys()):
+            if module in testcase.test_modules:
+                a += result.files[module].str_with_options(options).split("\n")
+    except CompileError as e:
+        a = e.messages
+    if testcase.normalize_output:
+        a = normalize_error_messages(a)
+    assert_string_arrays_equal(
+        testcase.output,
+        a,
+        f"Invalid semantic analyzer output ({testcase.file}, line {testcase.line})",
+    )
+
+
+# Semantic analyzer error test cases
+
+
+class SemAnalErrorSuite(DataSuite):
+    files = ["semanal-errors.test"]
+    if sys.version_info >= (3, 10):
+        semanal_files.append("semanal-errors-python310.test")
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        test_semanal_error(testcase)
+
+
+def test_semanal_error(testcase: DataDrivenTestCase) -> None:
+    """Perform a test case."""
+
+    try:
+        src = "\n".join(testcase.input)
+        res = build.build(
+            sources=[BuildSource("main", None, src)],
+            options=get_semanal_options(src, testcase),
+            alt_lib_path=test_temp_dir,
+        )
+        a = res.errors
+    except CompileError as e:
+        # Verify that there was a compile error and that the error messages
+        # are equivalent.
+        a = e.messages
+    if testcase.normalize_output:
+        a = normalize_error_messages(a)
+    assert_string_arrays_equal(
+        testcase.output, a, f"Invalid compiler output ({testcase.file}, line {testcase.line})"
+    )
+
+
+# SymbolNode table export test cases
+
+
+class SemAnalSymtableSuite(DataSuite):
+    required_out_section = True
+    files = ["semanal-symtable.test"]
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        """Perform a test case."""
+        try:
+            # Build test case input.
+            src = "\n".join(testcase.input)
+            result = build.build(
+                sources=[BuildSource("main", None, src)],
+                options=get_semanal_options(src, testcase),
+                alt_lib_path=test_temp_dir,
+            )
+            # The output is the symbol table converted into a string.
+            a = result.errors
+            if a:
+                raise CompileError(a)
+            for module in sorted(result.files.keys()):
+                if module in testcase.test_modules:
+                    a.append(f"{module}:")
+                    for s in str(result.files[module].names).split("\n"):
+                        a.append("  " + s)
+        except CompileError as e:
+            a = e.messages
+        assert_string_arrays_equal(
+            testcase.output,
+            a,
+            f"Invalid semantic analyzer output ({testcase.file}, line {testcase.line})",
+        )
+
+
+# Type info export test cases
+class SemAnalTypeInfoSuite(DataSuite):
+    required_out_section = True
+    files = ["semanal-typeinfo.test"]
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        """Perform a test case."""
+        try:
+            # Build test case input.
+            src = "\n".join(testcase.input)
+            result = build.build(
+                sources=[BuildSource("main", None, src)],
+                options=get_semanal_options(src, testcase),
+                alt_lib_path=test_temp_dir,
+            )
+            a = result.errors
+            if a:
+                raise CompileError(a)
+
+            # Collect all TypeInfos in top-level modules.
+            typeinfos = TypeInfoMap()
+            for module, file in result.files.items():
+                if module in testcase.test_modules:
+                    for n in file.names.values():
+                        if isinstance(n.node, TypeInfo):
+                            assert n.fullname
+                            if any(n.fullname.startswith(m + ".") for m in testcase.test_modules):
+                                typeinfos[n.fullname] = n.node
+
+            # The output is the symbol table converted into a string.
+            a = str(typeinfos).split("\n")
+        except CompileError as e:
+            a = e.messages
+        assert_string_arrays_equal(
+            testcase.output,
+            a,
+            f"Invalid semantic analyzer output ({testcase.file}, line {testcase.line})",
+        )
+
+
+class TypeInfoMap(Dict[str, TypeInfo]):
+    def __str__(self) -> str:
+        a: list[str] = ["TypeInfoMap("]
+        for x, y in sorted(self.items()):
+            ti = ("\n" + "  ").join(str(y).split("\n"))
+            a.append(f"  {x} : {ti}")
+        a[-1] += ")"
+        return "\n".join(a)