sflkit 0.2.18__tar.gz → 0.2.19__tar.gz

{sflkit-0.2.18/src/sflkit.egg-info → sflkit-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sflkit
-Version: 0.2.18
+Version: 0.2.19
 Summary: SFLKit: : A Workbench for Statistical Fault Localization
 Author-email: Marius Smytzek <marius.smytzek@cispa.de>
 Project-URL: Homepage, https://github.com/uds-se/sflkit/

{sflkit-0.2.18 → sflkit-0.2.19}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sflkit"
-version = "0.2.18"
+version = "0.2.19"
 authors = [
     { name = "Marius Smytzek", email = "marius.smytzek@cispa.de" },
 ]

sflkit-0.2.19/src/sflkit/runners/resources/pytest_main.py

@@ -0,0 +1,82 @@
+import os
+import sys
+from typing import Optional, Union, List, Sequence
+
+# noinspection PyPackageRequirements
+from _pytest._code import ExceptionInfo
+
+# noinspection PyPackageRequirements
+from _pytest._io import TerminalWriter
+
+# noinspection PyPackageRequirements
+from _pytest.config import (
+    ExitCode,
+    _prepareconfig,
+    ConftestImportFailure,
+    UsageError,
+    filter_traceback_for_conftest_import_failure,
+    _PluggyPlugin,
+)
+
+
+def pytest_collection_finish(session):
+    """
+    Called after collection has been performed and modified.
+    """
+    file = os.getenv("SFLKIT_PYTEST_COLLECTION_FINISH_FILE", "tmp_sflkit_pytest")
+    with open(file, "w") as f:
+        for item in session.items:
+            f.write(item.nodeid + "\n")
+
+
+def main(
+    args: Optional[Union[List[str], "os.PathLike[str]"]] = None,
+    plugins: Optional[Sequence[Union[str, _PluggyPlugin]]] = None,
+) -> Union[int, ExitCode]:
+    """Perform an in-process test run.
+
+    :param args: List of command line arguments.
+    :param plugins: List of plugin objects to be auto-registered during initialization.
+
+    :returns: An exit code.
+    """
+    try:
+        try:
+            config = _prepareconfig(args, plugins)
+        except ConftestImportFailure as e:
+            exc_info = ExceptionInfo.from_exc_info(e.excinfo)
+            tw = TerminalWriter(sys.stderr)
+            tw.line(f"ImportError while loading conftest '{e.path}'.", red=True)
+            exc_info.traceback = exc_info.traceback.filter(
+                filter_traceback_for_conftest_import_failure
+            )
+            exc_repr = (
+                exc_info.getrepr(style="short", chain=False)
+                if exc_info.traceback
+                else exc_info.exconly()
+            )
+            formatted_tb = str(exc_repr)
+            for line in formatted_tb.splitlines():
+                tw.line(line.rstrip(), red=True)
+            return ExitCode.USAGE_ERROR
+        else:
+            try:
+                config.hook.pytest_collection_finish = pytest_collection_finish
+                ret: Union[ExitCode, int] = config.hook.pytest_cmdline_main(
+                    config=config
+                )
+                try:
+                    return ExitCode(ret)
+                except ValueError:
+                    return ret
+            finally:
+                config._ensure_unconfigure()
+    except UsageError as e:
+        tw = TerminalWriter(sys.stderr)
+        for msg in e.args:
+            tw.line(f"ERROR: {msg}\n", red=True)
+        return ExitCode.USAGE_ERROR
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

{sflkit-0.2.18 → sflkit-0.2.19}/src/sflkit/runners/run.py

@@ -9,6 +9,8 @@ import subprocess
 from pathlib import Path
 from typing import List, Dict, Optional, Tuple
 
+from sflkit.logger import LOGGER
+
 Environment = Dict[str, str]
 
 PYTEST_RESULT_PATTERN = re.compile(
@@ -118,6 +120,15 @@ class VoidRunner(Runner):
 
 
 class PytestRunner(Runner):
+    def __init__(
+        self,
+        re_filter: str = r".*",
+        timeout=DEFAULT_TIMEOUT,
+        set_python_path: bool = False,
+    ):
+        super().__init__(re_filter, timeout)
+        self.set_python_path = set_python_path
+
     @staticmethod
     def _common_base(directory: Path, tests: List[str]) -> Path:
         parts = directory.parts
@@ -165,25 +176,49 @@ class PytestRunner(Runner):
         directory = directory.absolute()
         if files:
             if isinstance(files, (str, os.PathLike)):
-                c.append(files)
+                c.append(str(files))
             else:
-                c += files
+                c += [str(f) for f in files]
         if base:
             if not files:
-                c.append(base)
+                c.append(str(base))
             root_dir = directory / base
         else:
             root_dir = directory
-        output = subprocess.run(
-            ["python", "-m", "pytest", "--collect-only", "-q"] + c,
+        tmp = Path(f"tmp_sflkit_pytest_tmp_{id(self)}").absolute()
+        pytest_main = (
+            Path(__file__).parent.resolve() / "resources" / "pytest_main.py"
+        ).absolute()
+        environ = dict(environ or os.environ)
+        environ["SFLKIT_PYTEST_COLLECTION_FINISH_FILE"] = str(tmp)
+        if self.set_python_path:
+            if "PYTHONPATH" in environ:
+                environ["PYTHONPATH"] = str(directory) + ":" + environ["PYTHONPATH"]
+            else:
+                environ["PYTHONPATH"] = str(directory)
+        process = subprocess.run(
+            [
+                "python3",
+                str(pytest_main),
+                "--collect-only",
+            ]
+            + c,
             stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
             env=environ,
             cwd=directory,
-        ).stdout.decode("utf-8")
-        tests = output.split("\n\n", 1)[0].split("\n")
-        if tests[-1] == "":
-            tests = tests[:-1]
-        return self._normalize_paths(tests, directory, root_dir)
+        )
+        LOGGER.info(f"pytest collection finished with {process.returncode}")
+        if not tmp.exists():
+            tmp = directory / "tmp_sflkit_pytest"
+        if tmp.exists():
+            with open(tmp, "r") as f:
+                tests = [line.strip() for line in f.readlines()]
+            os.remove(tmp)
+            return self._normalize_paths(tests, directory, root_dir)
+        else:
+            LOGGER.warn(f"Could not find {tmp}")
+            return []
 
     @staticmethod
     def __get_pytest_result__(
@@ -207,7 +242,7 @@ class PytestRunner(Runner):
     ) -> TestResult:
         try:
             output = subprocess.run(
-                ["python", "-m", "pytest", test],
+                ["python3", "-m", "pytest", test],
                 stdout=subprocess.PIPE,
                 env=environ,
                 cwd=directory,
@@ -288,7 +323,7 @@ class InputRunner(Runner):
             result = TestResult.FAILING
         try:
             process = subprocess.run(
-                ["python", self.access] + test,
+                ["python3", self.access] + test,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 env=environ,

{sflkit-0.2.18 → sflkit-0.2.19/src/sflkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sflkit
-Version: 0.2.18
+Version: 0.2.19
 Summary: SFLKit: : A Workbench for Statistical Fault Localization
 Author-email: Marius Smytzek <marius.smytzek@cispa.de>
 Project-URL: Homepage, https://github.com/uds-se/sflkit/

{sflkit-0.2.18 → sflkit-0.2.19}/src/sflkit.egg-info/SOURCES.txt

@@ -42,6 +42,8 @@ src/sflkit/model/model.py
 src/sflkit/model/scope.py
 src/sflkit/runners/__init__.py
 src/sflkit/runners/run.py
+src/sflkit/runners/resources/__init__.py
+src/sflkit/runners/resources/pytest_main.py
 tests/test_analysis_objects.py
 tests/test_cli.py
 tests/test_color.py

{sflkit-0.2.18 → sflkit-0.2.19}/tests/test_instrumentation.py

@@ -2,8 +2,7 @@ import atexit
 import os
 from pathlib import Path
 
-from parameterized import parameterized
-from sflkitlib.events import event, EventType
+from sflkitlib.events import EventType
 
 from sflkit import instrument_config, Config
 from utils import BaseTest
@@ -121,6 +120,61 @@ class TestInstrumentation(BaseTest):
         self.assertTrue(mapping.exists())
         self.assertTrue(mapping.is_file())
 
+    def test_instrument_exclude(self):
+        src = Path(BaseTest.TEST_RESOURCES, "test_exclude")
+        dst = Path(BaseTest.TEST_DIR)
+        instrument_config(
+            Config.create(
+                path=str(src),
+                language="python",
+                events="line",
+                predicates="line",
+                working=BaseTest.TEST_DIR,
+                include="included",
+                exclude=os.path.join("included", "excluded"),
+            )
+        )
+        included = dst / "included"
+        excluded = included / "excluded"
+        a = included / "a.py"
+        b = excluded / "b.py"
+        c = dst / "c.py"
+
+        included_src = src / "included"
+        excluded_src = included_src / "excluded"
+        a_src = included_src / "a.py"
+        b_src = excluded_src / "b.py"
+        c_src = src / "c.py"
+
+        self.assertTrue(included.exists())
+        self.assertTrue(included.is_dir())
+        self.assertTrue(excluded.exists())
+        self.assertTrue(excluded.is_dir())
+        self.assertTrue(a.exists())
+        self.assertTrue(a.is_file())
+        self.assertTrue(b.exists())
+        self.assertTrue(b.is_file())
+        self.assertTrue(c.exists())
+        self.assertTrue(c.is_file())
+
+        with open(a, "r") as fp:
+            a_content = fp.read()
+        with open(a_src, "r") as fp:
+            a_src_content = fp.read()
+        self.assertNotEqual(a_src_content, a_content)
+
+        with open(b, "r") as fp:
+            b_content = fp.read()
+        with open(b_src, "r") as fp:
+            b_src_content = fp.read()
+        self.assertEqual(b_src_content, b_content)
+
+        with open(c, "r") as fp:
+            c_content = fp.read()
+        with open(c_src, "r") as fp:
+            c_src_content = fp.read()
+        self.assertEqual(c_src_content, c_content)
+
 
 class TestLib(BaseTest):
     @classmethod
@@ -146,10 +200,6 @@ class TestLib(BaseTest):
     def setUp(self) -> None:
         self.events = None
 
-    def load(self) -> None:
-        self.lib.dump_events()
-        self.events = event.load(self.TEST_PATH)
-
     def tearDown(self) -> None:
         # noinspection PyBroadException
         try:

{sflkit-0.2.18 → sflkit-0.2.19}/tests/test_runner.py

@@ -37,7 +37,7 @@ class RunnerTests(BaseTest):
             exclude="tests",
         )
         instrument_config(config)
-        runner = PytestRunner()
+        runner = PytestRunner(set_python_path=True)
         output = Path(BaseTest.TEST_DIR, "events").absolute()
         runner.run(
             Path(BaseTest.TEST_DIR), output, files=[Path("tests", "test_middle.py")]