mutmut 3.3.0__tar.gz → 3.3.1__tar.gz

{mutmut-3.3.0 → mutmut-3.3.1}/HISTORY.rst

@@ -1,6 +1,22 @@
 Changelog
 ---------
 
+3.3.1
+~~~~~
+
+* Increased threshold for mutant timeouts
+
+* Added `tests_dir` config. Accepts a single entry or a list of directories.
+
+* Async generators fixes
+
+* Fixed bad mutations for certain string escape sequences
+
+* Performance fixes
+
+* Various internal bug fixes
+
+
 3.3.0
 ~~~~~
 

{mutmut-3.3.0 → mutmut-3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mutmut
-Version: 3.3.0
+Version: 3.3.1
 Summary: mutation testing for Python 3
 Home-page: https://github.com/boxed/mutmut
 Author: Anders Hovmöller
@@ -88,6 +88,9 @@ You can also write a mutant to disk from the `browse` interface, or via
 source code control and committed before you apply a mutant!
 
 
+If during the installation you get an error for the `libcst` dependency mentioning the lack of a rust compiler on your system, it is because your architecture does not have a prebuilt binary for `libcst` and it requires both `rustc` and `cargo` from the [rust toolchain](https://www.rust-lang.org/tools/install) to be built. This is known for at least the `x86_64-darwin` architecture.
+
+
 Configuration
 -------------
 
@@ -173,6 +176,20 @@ You can exclude files from mutation in `setup.cfg`:
         *__tests.py
 
 
+Enable debug output (increase verbosity)
+----------------------------------------
+
+By default, mutmut "swallows" all the test output etc. so that you get a nice clean output.
+
+If you want to see all the detail to aid with debugging, you can set `debug` to `true` in your configuration.
+Note that not all displayed errors are necessarily bad. In particular test runs of the mutated code will lead
+to failing tests.
+
+.. code-block::
+
+    debug=true
+
+
 Whitelisting
 ------------
 

{mutmut-3.3.0 → mutmut-3.3.1}/README.rst

@@ -64,6 +64,9 @@ You can also write a mutant to disk from the `browse` interface, or via
 source code control and committed before you apply a mutant!
 
 
+If during the installation you get an error for the `libcst` dependency mentioning the lack of a rust compiler on your system, it is because your architecture does not have a prebuilt binary for `libcst` and it requires both `rustc` and `cargo` from the [rust toolchain](https://www.rust-lang.org/tools/install) to be built. This is known for at least the `x86_64-darwin` architecture.
+
+
 Configuration
 -------------
 
@@ -149,6 +152,20 @@ You can exclude files from mutation in `setup.cfg`:
         *__tests.py
 
 
+Enable debug output (increase verbosity)
+----------------------------------------
+
+By default, mutmut "swallows" all the test output etc. so that you get a nice clean output.
+
+If you want to see all the detail to aid with debugging, you can set `debug` to `true` in your configuration.
+Note that not all displayed errors are necessarily bad. In particular test runs of the mutated code will lead
+to failing tests.
+
+.. code-block::
+
+    debug=true
+
+
 Whitelisting
 ------------
 

{mutmut-3.3.0 → mutmut-3.3.1}/mutmut/__init__.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 
-__version__ = '3.3.0'
+__version__ = '3.3.1'
 
 
 duration_by_test = {}

{mutmut-3.3.0 → mutmut-3.3.1}/mutmut/__main__.py

@@ -4,7 +4,7 @@ import gc
 import inspect
 import itertools
 import json
-from multiprocessing import Pool, set_start_method
+from multiprocessing import Pool, set_start_method, Lock
 import os
 import resource
 import shutil
@@ -47,7 +47,9 @@ from typing import (
     Dict,
     List,
     Union,
+    Optional,
 )
+import warnings
 
 import click
 import libcst as cst
@@ -77,6 +79,7 @@ status_by_exit_code = {
     34: 'skipped',
     35: 'suspicious',
     36: 'timeout',
+    -24: 'timeout',  # SIGXCPU
     24: 'timeout',  # SIGXCPU
     152: 'timeout',  # SIGXCPU
     255: 'timeout',
@@ -176,6 +179,13 @@ class BadTestExecutionCommandsException(Exception):
         super().__init__(msg)
 
 
+class InvalidGeneratedSyntaxException(Exception):
+    def __init__(self, file: Union[Path, str]) -> None:
+        super().__init__(f'Mutmut generated invalid python syntax for {file}. '
+                          'If the original file has valid python syntax, please file an issue '
+                          'with a minimal reproducible example file.')
+
+
 def copy_src_dir():
     for path in mutmut.config.paths_to_mutate:
         output_path: Path = Path('mutants') / path
@@ -185,21 +195,33 @@ def copy_src_dir():
             output_path.parent.mkdir(exist_ok=True, parents=True)
             shutil.copyfile(path, output_path)
 
+@dataclass
+class FileMutationResult:
+    """Dataclass to transfer warnings and errors from child processes to the parent"""
+    warnings: list[Warning]
+    error: Optional[Exception] = None
 
 def create_mutants(max_children: int):
     with Pool(processes=max_children) as p:
-        p.map(create_file_mutants, walk_source_files())
-
+        for result in p.imap_unordered(create_file_mutants, walk_source_files()):
+            for warning in result.warnings:
+                warnings.warn(warning)
+            if result.error:
+                raise result.error
 
-def create_file_mutants(path: Path):
-    print(path)
-    output_path = Path('mutants') / path
-    makedirs(output_path.parent, exist_ok=True)
+def create_file_mutants(path: Path) -> FileMutationResult:
+    try:
+        print(path)
+        output_path = Path('mutants') / path
+        makedirs(output_path.parent, exist_ok=True)
 
-    if mutmut.config.should_ignore_for_mutation(path):
-        shutil.copy(path, output_path)
-    else:
-        create_mutants_for_file(path, output_path)
+        if mutmut.config.should_ignore_for_mutation(path):
+            shutil.copy(path, output_path)
+            return FileMutationResult(warnings=[])
+        else:
+            return create_mutants_for_file(path, output_path)
+    except Exception as e:
+        return FileMutationResult(warnings=[], error=e)
 
 
 def copy_also_copy_files():
@@ -215,23 +237,30 @@ def copy_also_copy_files():
         else:
             shutil.copytree(path, destination, dirs_exist_ok=True)
 
-
-def create_mutants_for_file(filename, output_path):
+def create_mutants_for_file(filename, output_path) -> FileMutationResult:
     input_stat = os.stat(filename)
+    warnings: list[Warning] = []
 
     with open(filename) as f:
         source = f.read()
 
     with open(output_path, 'w') as out:
-        mutant_names, hash_by_function_name = write_all_mutants_to_file(out=out, source=source, filename=filename)
+        try:
+            mutant_names, hash_by_function_name = write_all_mutants_to_file(out=out, source=source, filename=filename)
+        except cst.ParserSyntaxError as e:
+            # if libcst cannot parse it, then copy the source without any mutations
+            warnings.append(SyntaxWarning(f'Unsupported syntax in {filename} ({str(e)}), skipping'))
+            out.write(source)
+            mutant_names, hash_by_function_name = [], {}
 
     # validate no syntax errors of mutants
     with open(output_path) as f:
         try:
             ast.parse(f.read())
         except (IndentationError, SyntaxError) as e:
-            print(output_path, 'has invalid syntax: ', e)
-            exit(1)
+            invalid_syntax_error = InvalidGeneratedSyntaxException(output_path)
+            invalid_syntax_error.__cause__ = e
+            return FileMutationResult(warnings=warnings, error=invalid_syntax_error)
 
     source_file_mutation_data = SourceFileMutationData(path=filename)
     module_name = strip_prefix(str(filename)[:-len(filename.suffix)].replace(os.sep, '.'), prefix='src.')
@@ -245,6 +274,7 @@ def create_mutants_for_file(filename, output_path):
     source_file_mutation_data.save()
 
     os.utime(output_path, (input_stat.st_atime, input_stat.st_mtime))
+    return FileMutationResult(warnings=warnings)
 
 
 def write_all_mutants_to_file(*, out, source, filename):
@@ -282,7 +312,8 @@ class SourceFileMutationData:
 
     def register_pid(self, *, pid, key, estimated_time_of_tests):
         self.key_by_pid[pid] = key
-        self.start_time_by_pid[pid] = datetime.now()
+        with START_TIMES_BY_PID_LOCK:
+            self.start_time_by_pid[pid] = datetime.now()
         self.estimated_time_of_tests_by_pid[pid] = estimated_time_of_tests
 
     def register_result(self, *, pid, exit_code):
@@ -290,7 +321,8 @@ class SourceFileMutationData:
         self.exit_code_by_key[self.key_by_pid[pid]] = exit_code
         # TODO: maybe rate limit this? Saving on each result can slow down mutation testing a lot if the test run is fast.
         del self.key_by_pid[pid]
-        del self.start_time_by_pid[pid]
+        with START_TIMES_BY_PID_LOCK:
+            del self.start_time_by_pid[pid]
         self.save()
 
     def stop_children(self):
@@ -397,16 +429,34 @@ class PytestRunner(TestRunner):
 
         stats_collector = StatsCollector()
 
+        pytest_args = ['-x', '-q']
+        if tests:
+            pytest_args += list(tests)
+        else:
+            tests_dir = mutmut.config.tests_dir
+            if tests_dir:
+                pytest_args += tests_dir
         with change_cwd('mutants'):
-            return int(self.execute_pytest(['-x', '-q'] + list(tests), plugins=[stats_collector]))
+            return int(self.execute_pytest(pytest_args, plugins=[stats_collector]))
 
     def run_tests(self, *, mutant_name, tests):
+        pytest_args = ['-x', '-q']
+        if tests:
+            pytest_args += list(tests)
+        else:
+            tests_dir = mutmut.config.tests_dir
+            if tests_dir:
+                pytest_args += tests_dir
         with change_cwd('mutants'):
-            return int(self.execute_pytest(['-x', '-q'] + list(tests)))
+            return int(self.execute_pytest(pytest_args))
 
     def run_forced_fail(self):
+        pytest_args = ['-x', '-q']
+        tests_dir = mutmut.config.tests_dir
+        if tests_dir:
+            pytest_args += tests_dir
         with change_cwd('mutants'):
-            return int(self.execute_pytest(['-x', '-q']))
+            return int(self.execute_pytest(pytest_args))
 
     def list_all_tests(self):
         class TestsCollector:
@@ -415,8 +465,13 @@ class PytestRunner(TestRunner):
 
         collector = TestsCollector()
 
+        tests_dir = mutmut.config.tests_dir
+        pytest_args = ['-x', '-q', '--collect-only']
+        if tests_dir:
+            pytest_args += tests_dir
+
         with change_cwd('mutants'):
-            exit_code = int(self.execute_pytest(['-x', '-q', '--collect-only'], plugins=[collector]))
+            exit_code = int(self.execute_pytest(pytest_args, plugins=[collector]))
             if exit_code != 0:
                 raise CollectTestsFailedException()
 
@@ -620,6 +675,7 @@ class Config:
     max_stack_depth: int
     debug: bool
     paths_to_mutate: List[Path]
+    tests_dir: List[str] = None
 
     def should_ignore_for_mutation(self, path):
         if not str(path).endswith('.py'):
@@ -698,7 +754,8 @@ def load_config():
         paths_to_mutate=[
             Path(y)
             for y in s('paths_to_mutate', [])
-        ] or guess_paths_to_mutate()
+        ] or guess_paths_to_mutate(),
+        tests_dir=s('tests_dir', []),
     )
 
 
@@ -860,6 +917,9 @@ def stop_all_children(mutants):
     for m, _, _ in mutants:
         m.stop_children()
 
+# used to copy the global mutmut.config to subprocesses
+set_start_method('fork')
+START_TIMES_BY_PID_LOCK = Lock()
 
 def timeout_checker(mutants):
     def inner_timout_checker():
@@ -868,9 +928,12 @@ def timeout_checker(mutants):
 
             now = datetime.now()
             for m, mutant_name, result in mutants:
-                for pid, start_time in m.start_time_by_pid.items():
+                # copy dict inside lock, so it is not modified by another process while we iterate it
+                with START_TIMES_BY_PID_LOCK:
+                    start_times_by_pid = dict(m.start_time_by_pid)
+                for pid, start_time in start_times_by_pid.items():
                     run_time = now - start_time
-                    if run_time.total_seconds() > (m.estimated_time_of_tests_by_mutant[mutant_name] + 1) * 4:
+                    if run_time.total_seconds() > (m.estimated_time_of_tests_by_mutant[mutant_name] + 1) * 15:
                         try:
                             os.kill(pid, signal.SIGXCPU)
                         except ProcessLookupError:
@@ -882,9 +945,6 @@ def timeout_checker(mutants):
 @click.option('--max-children', type=int)
 @click.argument('mutant_names', required=False, nargs=-1)
 def run(mutant_names, *, max_children):
-    # used to copy the global mutmut.config to subprocesses
-    set_start_method('fork')
-
     assert isinstance(mutant_names, (tuple, list)), mutant_names
     _run(mutant_names, max_children)
 
@@ -1007,8 +1067,9 @@ def _run(mutant_names: Union[tuple, list], max_children: Union[None, int]):
                     os._exit(33)
 
                 estimated_time_of_tests = m.estimated_time_of_tests_by_mutant[mutant_name]
-                cpu_time_limit = ceil((estimated_time_of_tests + 1) * 2 + process_time()) * 10
-                resource.setrlimit(resource.RLIMIT_CPU, (cpu_time_limit, cpu_time_limit))
+                cpu_time_limit = ceil((estimated_time_of_tests + 1) * 30 + process_time())
+                # signal SIGXCPU after <cpu_time_limit>. One second later signal SIGKILL if it is still running
+                resource.setrlimit(resource.RLIMIT_CPU, (cpu_time_limit, cpu_time_limit + 1))
 
                 with CatchOutput():
                     result = runner.run_tests(mutant_name=mutant_name, tests=tests)
@@ -1098,16 +1159,24 @@ def read_orig_module(path) -> cst.Module:
         return cst.parse_module(f.read())
 
 
-def find_function(module: cst.Module, name: str) -> Union[cst.FunctionDef, None]:
+def find_top_level_function_or_method(module: cst.Module, name: str) -> Union[cst.FunctionDef, None]:
     name = name.split('.')[-1]
-    return next(iter(m.findall(module, m.FunctionDef(m.Name(name)))), None) # type: ignore
+    for child in module.body:
+        if isinstance(child, cst.FunctionDef) and child.name.value == name:
+            return child
+        if isinstance(child, cst.ClassDef) and isinstance(child.body, cst.IndentedBlock):
+            for method in child.body.body:
+                if isinstance(method, cst.FunctionDef) and method.name.value == name:
+                    return method
+
+    return None
 
 
 def read_original_function(module: cst.Module, mutant_name: str):
     orig_function_name, _ = orig_function_and_class_names_from_key(mutant_name)
     orig_name = mangled_name_from_mutant_name(mutant_name) + '__mutmut_orig'
 
-    result = find_function(module, orig_name)
+    result = find_top_level_function_or_method(module, orig_name)
     if not result:
         raise FileNotFoundError(f'Could not find original function "{orig_function_name}"')
     return result.with_changes(name = cst.Name(orig_function_name))
@@ -1116,7 +1185,7 @@ def read_original_function(module: cst.Module, mutant_name: str):
 def read_mutant_function(module: cst.Module, mutant_name: str):
     orig_function_name, _ = orig_function_and_class_names_from_key(mutant_name)
 
-    result = find_function(module, mutant_name)
+    result = find_top_level_function_or_method(module, mutant_name)
     if not result:
         raise FileNotFoundError(f'Could not find original function "{orig_function_name}"')
     return result.with_changes(name = cst.Name(orig_function_name))
@@ -1189,7 +1258,7 @@ def apply_mutant(mutant_name):
     mutant_function = read_mutant_function(mutants_module, mutant_name)
     mutant_function = mutant_function.with_changes(name=cst.Name(orig_function_name))
 
-    original_function = find_function(orig_module, orig_function_name)
+    original_function = find_top_level_function_or_method(orig_module, orig_function_name)
     if not original_function:
         raise FileNotFoundError(f'Could not apply mutant {mutant_name}')
 
@@ -1263,6 +1332,7 @@ def browse(show_killed):
         def read_data(self):
             ensure_config_loaded()
             self.source_file_mutation_data_and_stat_by_path = {}
+            self.path_by_name = {}
 
             for p in walk_source_files():
                 if mutmut.config.should_ignore_for_mutation(p):
@@ -1272,6 +1342,8 @@ def browse(show_killed):
                 stat = collect_stat(source_file_mutation_data)
 
                 self.source_file_mutation_data_and_stat_by_path[str(p)] = source_file_mutation_data, stat
+                for name in source_file_mutation_data.exit_code_by_key:
+                    self.path_by_name[name] = p
 
         def populate_files_table(self):
             # noinspection PyTypeChecker
@@ -1310,11 +1382,12 @@ def browse(show_killed):
                 else:
                     diff_view.update('<loading...>')
                     self.loading_id = event.row_key.value
+                    path = self.path_by_name.get(event.row_key.value)
 
                     def load_thread():
                         ensure_config_loaded()
                         try:
-                            d = get_diff_for_mutant(event.row_key.value)
+                            d = get_diff_for_mutant(event.row_key.value, path=path)
                             if event.row_key.value == self.loading_id:
                                 diff_view.update(Syntax(d, "diff"))
                         except Exception as e:

{mutmut-3.3.0 → mutmut-3.3.1}/mutmut/file_mutation.py

@@ -8,7 +8,7 @@ import warnings
 import libcst as cst
 from libcst.metadata import PositionProvider, MetadataWrapper
 import libcst.matchers as m
-from mutmut.trampoline_templates import build_trampoline, mangle_function_name, trampoline_impl, yield_from_trampoline_impl
+from mutmut.trampoline_templates import build_trampoline, mangle_function_name, trampoline_impl
 from mutmut.node_mutation import mutation_operators, OPERATORS_TYPE
 
 NEVER_MUTATE_FUNCTION_NAMES = { "__getattribute__", "__setattr__", "__new__" }
@@ -25,11 +25,7 @@ def mutate_file_contents(filename: str, code: str) -> tuple[str, Sequence[str]]:
     """Create mutations for `code` and merge them to a single mutated file with trampolines.
 
     :return: A tuple of (mutated code, list of mutant function names)"""
-    try:
-        module, mutations = create_mutations(code)
-    except cst.ParserSyntaxError as e:
-        warnings.warn(SyntaxWarning(f'Unsupported syntax in {filename} ({str(e)}), skipping'))
-        return code, []
+    module, mutations = create_mutations(code)
 
     return combine_mutations_to_source(module, mutations)
 
@@ -165,8 +161,6 @@ MODULE_STATEMENT = Union[cst.SimpleStatementLine, cst.BaseCompoundStatement]
 # convert str trampoline implementations to CST nodes with some whitespace
 trampoline_impl_cst = list(cst.parse_module(trampoline_impl).body)
 trampoline_impl_cst[-1] = trampoline_impl_cst[-1].with_changes(leading_lines = [cst.EmptyLine(), cst.EmptyLine()])
-yield_from_trampoline_impl_cst = list(cst.parse_module(yield_from_trampoline_impl).body)
-yield_from_trampoline_impl_cst[-1] = yield_from_trampoline_impl_cst[-1].with_changes(leading_lines = [cst.EmptyLine(), cst.EmptyLine()])
 
 
 def combine_mutations_to_source(module: cst.Module, mutations: Sequence[Mutation]) -> tuple[str, Sequence[str]]:
@@ -185,7 +179,6 @@ def combine_mutations_to_source(module: cst.Module, mutations: Sequence[Mutation
 
     # trampoline functions
     result.extend(trampoline_impl_cst)
-    result.extend(yield_from_trampoline_impl_cst)
 
     mutations_within_function = group_by_top_level_node(mutations)
 
@@ -234,7 +227,6 @@ def function_trampoline_arrangement(function: cst.FunctionDef, mutants: Iterable
 
     name = function.name.value
     mangled_name = mangle_function_name(name=name, class_name=class_name) + '__mutmut'
-    _is_generator = is_generator(function)
 
     # copy of original function
     nodes.append(function.with_changes(name=cst.Name(mangled_name + '_orig')))
@@ -248,7 +240,7 @@ def function_trampoline_arrangement(function: cst.FunctionDef, mutants: Iterable
         nodes.append(mutated_method) # type: ignore
 
     # trampoline that forwards the calls
-    trampoline = list(cst.parse_module(build_trampoline(orig_name=name, mutants=mutant_names, class_name=class_name, is_generator=_is_generator)).body)
+    trampoline = list(cst.parse_module(build_trampoline(orig_name=name, mutants=mutant_names, class_name=class_name)).body)
     trampoline[0] = trampoline[0].with_changes(leading_lines=[cst.EmptyLine()])
     nodes.extend(trampoline)
 
@@ -274,28 +266,6 @@ def group_by_top_level_node(mutations: Sequence[Mutation]) -> Mapping[cst.CSTNod
 
     return grouped
 
-def is_generator(function: cst.FunctionDef) -> bool:
-    """Return True if the function has yield statement(s)."""
-    visitor = IsGeneratorVisitor(function)
-    function.visit(visitor)
-    return visitor.is_generator
-
-class IsGeneratorVisitor(cst.CSTVisitor):
-    """Check if a function is a generator.
-    We do so by checking if any child is a Yield statement, but not looking into inner function definitions."""
-    def __init__(self, original_function: cst.FunctionDef):
-        self.is_generator = False
-        self.original_function: cst.FunctionDef = original_function
-
-    def visit_FunctionDef(self, node):
-        # do not recurse into inner function definitions
-        if self.original_function != node:
-            return False
-
-    def visit_Yield(self, node):
-        self.is_generator = True
-        return False
-
 def pragma_no_mutate_lines(source: str) -> set[int]:
     return {
         i + 1

{mutmut-3.3.0 → mutmut-3.3.1}/mutmut/node_mutation.py

@@ -1,5 +1,6 @@
 """This module contains the mutations for indidvidual nodes, e.g. replacing a != b with a == b."""
-from typing import Any, Union
+import re
+from typing import Any, Union, cast
 from collections.abc import Callable, Iterable, Sequence
 import libcst as cst
 import libcst.matchers as m
@@ -11,6 +12,9 @@ OPERATORS_TYPE = Sequence[
     ]
 ]
 
+# pattern to match (nearly) all chars in a string that are not part of an escape sequence
+NON_ESCAPE_SEQUENCE = re.compile(r"((?<!\\)[^\\]+)")
+
 def operator_number(
     node: cst.BaseNumber
 ) -> Iterable[cst.BaseNumber]:
@@ -39,9 +43,9 @@ def operator_string(
 
         supported_str_mutations: list[Callable[[str], str]] = [
             lambda x: "XX" + x + "XX",
-            lambda x: x.lower(),
-            lambda x: x.upper(),
-            lambda x: x.capitalize(),
+            # do not modify escape sequences, as this could break python syntax
+            lambda x: NON_ESCAPE_SEQUENCE.sub(lambda match: match.group(1).lower(), x),
+            lambda x: NON_ESCAPE_SEQUENCE.sub(lambda match: match.group(1).upper(), x),
         ]
 
         for mut_func in supported_str_mutations:
@@ -96,7 +100,7 @@ def operator_arg_removal(
             yield node.with_changes(args=[*node.args[:i], *node.args[i + 1 :]])
 
 
-supported_str_methods_swap = [
+supported_symmetric_str_methods_swap = [
          ("lower", "upper"),
          ("upper", "lower"),
          ("lstrip", "rstrip"),
@@ -107,24 +111,42 @@ supported_str_methods_swap = [
          ("rjust", "ljust"),
          ("index", "rindex"),
          ("rindex", "index"),
-         ("split", "rsplit"),
-         ("rsplit", "split"),
          ("removeprefix", "removesuffix"),
          ("removesuffix", "removeprefix"),
          ("partition", "rpartition"),
          ("rpartition", "partition")
-     ]
+]
+
+supported_unsymmetrical_str_methods_swap = [
+    ("split", "rsplit"),
+    ("rsplit", "split")
+]
 
-def operator_string_methods_swap(
+def operator_symmetric_string_methods_swap(
      node: cst.Call
  ) -> Iterable[cst.Call]:
      """try to swap string method to opposite e.g. a.lower() -> a.upper()"""
 
-     for old_call, new_call in supported_str_methods_swap:
+     for old_call, new_call in supported_symmetric_str_methods_swap:
          if m.matches(node.func, m.Attribute(value=m.DoNotCare(),  attr=m.Name(value=old_call))):
             func_name = cst.ensure_type(node.func, cst.Attribute).attr
             yield node.with_deep_changes(func_name, value=new_call)
 
+def operator_unsymmetrical_string_methods_swap(
+    node: cst.Call
+) -> Iterable[cst.Call]:
+    """Try to handle specific mutations of string, which useful only in specific args combination."""
+    for old_call, new_call in supported_unsymmetrical_str_methods_swap:
+        if m.matches(node.func, m.Attribute(attr=m.Name(value=old_call))):
+            if old_call in {"split", "rsplit"}:
+                # The logic of this "if" operator described here:
+                # https://github.com/boxed/mutmut/pull/394#issuecomment-2977890188
+                key_args: set[str] = {a.keyword.value for a in node.args if a.keyword} # sep or maxsplit or nothing
+                if len(node.args) == 2 or "maxsplit" in key_args:
+                    func_name = cst.ensure_type(node.func, cst.Attribute).attr
+                    yield node.with_deep_changes(func_name, value=new_call)
+
+
 
 def operator_remove_unary_ops(
     node: cst.UnaryOperation
@@ -197,7 +219,11 @@ _operator_mapping: dict[type[cst.CSTNode], type[cst.CSTNode]] = {
 def operator_swap_op(
     node: cst.CSTNode
 ) -> Iterable[cst.CSTNode]:
-    yield from _simple_mutation_mapping(node, _operator_mapping)
+    if m.matches(node, m.BinaryOperation() | m.UnaryOperation() | m.BooleanOperation() | m.ComparisonTarget() | m.AugAssign()):
+        typed_node = cast(Union[cst.BinaryOperation, cst.UnaryOperation, cst.BooleanOperation, cst.ComparisonTarget, cst.AugAssign], node)
+        operator = typed_node.operator
+        for new_operator in _simple_mutation_mapping(operator, _operator_mapping):
+            yield node.with_changes(operator=new_operator)
 
 
 def operator_augmented_assignment(
@@ -238,7 +264,8 @@ mutation_operators: OPERATORS_TYPE = [
     (cst.UnaryOperation, operator_remove_unary_ops),
     (cst.Call, operator_dict_arguments),
     (cst.Call, operator_arg_removal),
-    (cst.Call, operator_string_methods_swap),
+    (cst.Call, operator_symmetric_string_methods_swap),
+    (cst.Call, operator_unsymmetrical_string_methods_swap),
     (cst.Lambda, operator_lambda),
     (cst.CSTNode, operator_keywords),
     (cst.CSTNode, operator_swap_op),

{mutmut-3.3.0 → mutmut-3.3.1}/mutmut/trampoline_templates.py

@@ -1,6 +1,6 @@
 CLASS_NAME_SEPARATOR = 'ǁ'
 
-def build_trampoline(*, orig_name, mutants, class_name, is_generator):
+def build_trampoline(*, orig_name, mutants, class_name):
     mangled_name = mangle_function_name(name=orig_name, class_name=class_name)
 
     mutants_dict = f'{mangled_name}__mutmut_mutants : ClassVar[MutantDict] = {{\n' + ', \n    '.join(f'{repr(m)}: {m}' for m in mutants) + '\n}'
@@ -12,18 +12,13 @@ def build_trampoline(*, orig_name, mutants, class_name, is_generator):
         access_suffix = '")'
         self_arg = ', self'
 
-    if is_generator:
-        yield_statement = 'yield from '  # note the space at the end!
-        trampoline_name = '_mutmut_yield_from_trampoline'
-    else:
-        yield_statement = ''
-        trampoline_name = '_mutmut_trampoline'
+    trampoline_name = '_mutmut_trampoline'
 
     return f"""
 {mutants_dict}
 
 def {orig_name}({'self, ' if class_name is not None else ''}*args, **kwargs):
-    result = {yield_statement}{trampoline_name}({access_prefix}{mangled_name}__mutmut_orig{access_suffix}, {access_prefix}{mangled_name}__mutmut_mutants{access_suffix}, args, kwargs{self_arg})
+    result = {trampoline_name}({access_prefix}{mangled_name}__mutmut_orig{access_suffix}, {access_prefix}{mangled_name}__mutmut_mutants{access_suffix}, args, kwargs{self_arg})
     return result 
 
 {orig_name}.__signature__ = _mutmut_signature({mangled_name}__mutmut_orig)
@@ -62,11 +57,11 @@ def _mutmut_trampoline(orig, mutants, call_args, call_kwargs, self_arg = None):
         from mutmut.__main__ import record_trampoline_hit
         record_trampoline_hit(orig.__module__ + '.' + orig.__name__)
         result = orig(*call_args, **call_kwargs)
-        return result  # for the yield case
+        return result
     prefix = orig.__module__ + '.' + orig.__name__ + '__mutmut_'
     if not mutant_under_test.startswith(prefix):
         result = orig(*call_args, **call_kwargs)
-        return result  # for the yield case
+        return result
     mutant_name = mutant_under_test.rpartition('.')[-1]
     if self_arg:
         # call to a class method where self is not bound
@@ -76,4 +71,3 @@ def _mutmut_trampoline(orig, mutants, call_args, call_kwargs, self_arg = None):
     return result
 
 """
-yield_from_trampoline_impl = trampoline_impl.replace('result = ', 'result = yield from ').replace('_mutmut_trampoline', '_mutmut_yield_from_trampoline')

{mutmut-3.3.0 → mutmut-3.3.1}/mutmut.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mutmut
-Version: 3.3.0
+Version: 3.3.1
 Summary: mutation testing for Python 3
 Home-page: https://github.com/boxed/mutmut
 Author: Anders Hovmöller
@@ -88,6 +88,9 @@ You can also write a mutant to disk from the `browse` interface, or via
 source code control and committed before you apply a mutant!
 
 
+If during the installation you get an error for the `libcst` dependency mentioning the lack of a rust compiler on your system, it is because your architecture does not have a prebuilt binary for `libcst` and it requires both `rustc` and `cargo` from the [rust toolchain](https://www.rust-lang.org/tools/install) to be built. This is known for at least the `x86_64-darwin` architecture.
+
+
 Configuration
 -------------
 
@@ -173,6 +176,20 @@ You can exclude files from mutation in `setup.cfg`:
         *__tests.py
 
 
+Enable debug output (increase verbosity)
+----------------------------------------
+
+By default, mutmut "swallows" all the test output etc. so that you get a nice clean output.
+
+If you want to see all the detail to aid with debugging, you can set `debug` to `true` in your configuration.
+Note that not all displayed errors are necessarily bad. In particular test runs of the mutated code will lead
+to failing tests.
+
+.. code-block::
+
+    debug=true
+
+
 Whitelisting
 ------------
 

{mutmut-3.3.0 → mutmut-3.3.1}/mutmut.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ setup.py
 ./mutmut/result_browser_layout.tcss
 ./mutmut/trampoline_templates.py
 ./tests/__init__.py
+./tests/test_generation_error_handling.py
 ./tests/test_mutation.py
 ./tests/test_mutmut3.py
 ./tests/e2e/__init__.py

mutmut-3.3.1/tests/test_generation_error_handling.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+from mutmut.__main__ import create_mutants, Config, InvalidGeneratedSyntaxException
+import mutmut.__main__
+import mutmut
+import pytest
+import os
+
+source_dir = Path(__file__).parent / 'data' / 'test_generation'
+source_dir = source_dir.relative_to(os.getcwd())
+
+class MockConfig:
+    def should_ignore_for_mutation(self, path: Path) -> bool:
+        return False
+
+def test_mutant_generation_raises_exception_on_invalid_syntax(monkeypatch):
+    mutmut._reset_globals()
+    mutmut.config = MockConfig()
+
+    source_files = [
+        source_dir / "valid_syntax_1.py",
+        source_dir / "valid_syntax_2.py",
+        source_dir / "valid_syntax_3.py",
+        source_dir / "valid_syntax_4.py",
+        source_dir / "invalid_syntax.py",
+    ]
+    monkeypatch.setattr(mutmut.__main__, "walk_source_files", lambda: source_files)
+    monkeypatch.setattr("mutmut.config.should_ignore_for_mutation", lambda _path: False)
+
+    # should raise an exception, because we copy the invalid_syntax.py file and then verify
+    # if it is valid syntax
+    with pytest.raises(InvalidGeneratedSyntaxException) as excinfo:
+        # should raise a warning, because libcst is not able to parse invalid_syntax.py
+        with pytest.warns(SyntaxWarning):
+            create_mutants(max_children=2)
+    assert 'invalid_syntax.py' in str(excinfo.value)

{mutmut-3.3.0 → mutmut-3.3.1}/tests/test_mutation.py

@@ -1,7 +1,7 @@
 import os
 from unittest.mock import Mock, patch
 import pytest
-from libcst import parse_statement
+import libcst as cst
 
 import mutmut
 from mutmut.__main__ import (
@@ -13,8 +13,8 @@ from mutmut.__main__ import (
     MutmutProgrammaticFailException,
     CatchOutput,
 )
-from mutmut.trampoline_templates import trampoline_impl, yield_from_trampoline_impl, mangle_function_name
-from mutmut.file_mutation import create_mutations, mutate_file_contents, is_generator
+from mutmut.trampoline_templates import trampoline_impl, mangle_function_name
+from mutmut.file_mutation import create_mutations, mutate_file_contents
 
 def mutants_for_source(source: str) -> list[str]:
     module, mutated_nodes = create_mutations(source)
@@ -62,8 +62,47 @@ def mutated_module(source: str) -> str:
         ]),
         ('a.index("+")', ['a.rindex("+")', 'a.index("XX+XX")', 'a.index(None)']),
         ('a.rindex("+")', ['a.index("+")', 'a.rindex("XX+XX")', 'a.rindex(None)']),
-        ('a.split()', 'a.rsplit()'),
-        ('a.rsplit()', 'a.split()'),
+        ('a.split()', []),
+        ('a.rsplit()', []),
+        ('a.split(" ")', ['a.split("XX XX")', 'a.split(None)']),
+        ('a.rsplit(" ")', ['a.rsplit("XX XX")', 'a.rsplit(None)']),
+        ('a.split(sep="")', ['a.split(sep="XXXX")', 'a.split(sep=None)']),
+        ('a.rsplit(sep="")', ['a.rsplit(sep="XXXX")', 'a.rsplit(sep=None)']),
+        ('a.split(maxsplit=-1)', [
+            'a.rsplit(maxsplit=-1)', 'a.split(maxsplit=+1)', 'a.split(maxsplit=-2)', 'a.split(maxsplit=None)'
+        ]),
+        ('a.rsplit(maxsplit=-1)', [
+            'a.split(maxsplit=-1)', 'a.rsplit(maxsplit=+1)', 'a.rsplit(maxsplit=-2)', 'a.rsplit(maxsplit=None)'
+        ]),
+        ('a.split(" ", maxsplit=-1)', [
+            'a.split(" ", )', 'a.split(" ", maxsplit=+1)', 'a.split(" ", maxsplit=-2)',
+            'a.split(" ", maxsplit=None)', 'a.split("XX XX", maxsplit=-1)', 'a.split(None, maxsplit=-1)',
+            'a.split(maxsplit=-1)', 'a.rsplit(" ", maxsplit=-1)'
+        ]),
+        ('a.rsplit(" ", maxsplit=-1)', [
+            'a.rsplit(" ", )', 'a.rsplit(" ", maxsplit=+1)', 'a.rsplit(" ", maxsplit=-2)',
+            'a.rsplit(" ", maxsplit=None)', 'a.rsplit("XX XX", maxsplit=-1)', 'a.rsplit(None, maxsplit=-1)',
+            'a.rsplit(maxsplit=-1)', 'a.split(" ", maxsplit=-1)'
+        ]),
+        ('a.split(maxsplit=1)', ['a.split(maxsplit=2)', 'a.split(maxsplit=None)', 'a.rsplit(maxsplit=1)']),
+        ('a.rsplit(maxsplit=1)', ['a.rsplit(maxsplit=2)', 'a.rsplit(maxsplit=None)', 'a.split(maxsplit=1)']),
+        ('a.split(" ", 1)', [
+            'a.rsplit(" ", 1)', 'a.split(" ", )', 'a.split(" ", 2)', 'a.split(" ", None)',
+            'a.split("XX XX", 1)', 'a.split(1)', 'a.split(None, 1)'
+        ]),
+        ('a.rsplit(" ", 1)', [
+            'a.rsplit(" ", )', 'a.rsplit(" ", 2)', 'a.rsplit(" ", None)', 'a.rsplit("XX XX", 1)',
+            'a.rsplit(1)', 'a.rsplit(None, 1)', 'a.split(" ", 1)'
+        ]),
+        ('a.split(" ", maxsplit=1)', [
+            'a.rsplit(" ", maxsplit=1)', 'a.split(" ", )', 'a.split(" ", maxsplit=2)', 'a.split(" ", maxsplit=None)',
+            'a.split("XX XX", maxsplit=1)', 'a.split(None, maxsplit=1)', 'a.split(maxsplit=1)'
+        ]),
+        ('a.rsplit(" ", maxsplit=1)', [
+            'a.rsplit(" ", )', 'a.rsplit(" ", maxsplit=2)', 'a.rsplit(" ", maxsplit=None)',
+            'a.rsplit("XX XX", maxsplit=1)', 'a.rsplit(None, maxsplit=1)', 'a.rsplit(maxsplit=1)',
+            'a.split(" ", maxsplit=1)'
+        ]),
         ('a.removeprefix("+")', ['a.removesuffix("+")', 'a.removeprefix("XX+XX")', 'a.removeprefix(None)']),
         ('a.removesuffix("+")', ['a.removeprefix("+")', 'a.removesuffix("XX+XX")', 'a.removesuffix(None)']),
         ('a.partition("++")', ['a.rpartition("++")', 'a.partition("XX++XX")', 'a.partition(None)']),
@@ -86,7 +125,9 @@ def mutated_module(source: str) -> str:
         ('x: list[A | None]', []),
         ('a: Optional[int] = None', 'a: Optional[int] = ""'),
         ('a: int = 1', ['a: int = 2', 'a: int = None']),
-        ('a: str = "FoO"', ['a: str = "XXFoOXX"', 'a: str = "foo"', 'a: str = "FOO"', 'a: str = "Foo"', 'a: str = None']),
+        ('a: str = "FoO"', ['a: str = "XXFoOXX"', 'a: str = "foo"', 'a: str = "FOO"', 'a: str = None']),
+        (r'a: str = "Fo\t"', [r'a: str = "XXFo\tXX"', r'a: str = "FO\t"', r'a: str = "fo\t"', 'a: str = None']),
+        (r'a: str = "Fo\N{ghost} \U11223344"', [r'a: str = "XXFo\N{ghost} \U11223344XX"', r'a: str = "FO\N{GHOST} \U11223344"', r'a: str = "fo\N{ghost} \U11223344"', 'a: str = None']),
         ('lambda: 0', ['lambda: 1', 'lambda: None']),
         ("1 in (1, 2)", ['2 in (1, 2)', '1 not in (1, 2)', '1 in (2, 2)', '1 in (1, 3)']),
         ('1+1', ['2+1', '1 - 1', '1+2']),
@@ -109,9 +150,9 @@ def mutated_module(source: str) -> str:
         ('1e-3', '1.001'),
         ('True', 'False'),
         ('False', 'True'),
-        ('"FoO"', ['"XXFoOXX"', '"foo"', '"FOO"', '"Foo"']),
-        ("'FoO'", ["'XXFoOXX'", "'foo'", "'FOO'", "'Foo'"]),
-        ("u'FoO'", ["u'XXFoOXX'", "u'foo'", "u'FOO'", "u'Foo'"]),
+        ('"FoO"', ['"XXFoOXX"', '"foo"', '"FOO"']),
+        ("'FoO'", ["'XXFoOXX'", "'foo'", "'FOO'"]),
+        ("u'FoO'", ["u'XXFoOXX'", "u'foo'", "u'FOO'"]),
         ("10", "11"),
         ("10.", "11.0"),
         ("0o10", "9"),
@@ -244,6 +285,19 @@ match x:
 
     assert sorted(mutants) == sorted(expected)
 
+def test_mach_case_does_not_mutate_bitor():
+    source = """
+def concat():
+    match x:
+        case A() | B():
+            pass
+"""
+
+    mutants = mutants_for_source(source)
+
+    assert sorted(mutants) == []
+
+
 def test_basic_class():
     source = """
 class Foo:
@@ -269,8 +323,8 @@ def test_function_with_annotation():
     print(mutated_code)
 
     expected_defs = [
-        'def x_capitalize__mutmut_1(s : str):\n    return s[1].title() + s[1:] if s else s',
-        'def x_capitalize__mutmut_2(s : str):\n    return s[0].title() - s[1:] if s else s',
+        'def x_capitalize__mutmut_1(s : str):\n    return s[0].title() - s[1:] if s else s',
+        'def x_capitalize__mutmut_2(s : str):\n    return s[1].title() + s[1:] if s else s',
         'def x_capitalize__mutmut_3(s : str):\n    return s[0].title() + s[2:] if s else s',
     ]
 
@@ -315,13 +369,10 @@ def test_mutate_dict():
     assert sorted(mutants) == sorted(expected)
 
 
-def test_syntax_warning():
-    with pytest.warns(SyntaxWarning) as record:
+def test_syntax_error():
+    with pytest.raises(cst.ParserSyntaxError):
         mutate_file_contents('some_file.py', ':!')
 
-    assert len(record) == 1
-    assert 'some_file.py' in record[0].message.args[0] # type: ignore
-
 
 def test_bug_github_issue_18():
     source = """
@@ -460,43 +511,6 @@ def foo():
     assert mutated_source.count('from __future__') == 1
 
 
-def test_preserve_generators():
-    source = '''
-    def foo():
-        yield 1
-    '''.strip()
-    mutated_source = mutated_module(source)
-    assert 'yield from _mutmut_yield_from_trampoline' in mutated_source
-
-
-def test_is_generator():
-    source = '''
-    def foo():
-        yield 1
-    '''.strip()
-    assert is_generator(parse_statement(source)) # type: ignore
-
-    source = '''
-    def foo():
-        yield from bar()
-    '''.strip()
-    assert is_generator(parse_statement(source)) # type: ignore
-
-    source = '''
-    def foo():
-        return 1
-    '''.strip()
-    assert not is_generator(parse_statement(source)) # type: ignore
-
-    source = '''
-    def foo():
-        def bar():
-            yield 2
-        return 1
-    '''.strip()
-    assert not is_generator(parse_statement(source)) # type: ignore
-
-
 # Negate the effects of CatchOutput because it does not play nicely with capfd in GitHub Actions
 @patch.object(CatchOutput, 'dump_output')
 @patch.object(CatchOutput, 'stop')
@@ -624,7 +638,6 @@ import lib
 
 lib.foo()
 {trampoline_impl.strip()}
-{yield_from_trampoline_impl.strip()}
 
 def x_foo__mutmut_orig(a, b):
     return a > b
@@ -654,7 +667,7 @@ x_bar__mutmut_mutants : ClassVar[MutantDict] = {{
 }}
 
 def bar(*args, **kwargs):
-    result = yield from _mutmut_yield_from_trampoline(x_bar__mutmut_orig, x_bar__mutmut_mutants, args, kwargs)
+    result = _mutmut_trampoline(x_bar__mutmut_orig, x_bar__mutmut_mutants, args, kwargs)
     return result 
 
 bar.__signature__ = _mutmut_signature(x_bar__mutmut_orig)

{mutmut-3.3.0 → mutmut-3.3.1}/tests/test_mutmut3.py

@@ -1,7 +1,4 @@
-from mutmut.trampoline_templates import (
-    trampoline_impl,
-    yield_from_trampoline_impl,
-)
+from mutmut.trampoline_templates import trampoline_impl
 from mutmut.file_mutation import mutate_file_contents
 
 def mutated_module(source: str) -> str:
@@ -16,7 +13,7 @@ a + 1
 def foo(a, b, c):
     return a + b * c
 """
-    trampolines = trampoline_impl.removesuffix('\n\n') + yield_from_trampoline_impl.removesuffix('\n\n')
+    trampolines = trampoline_impl.removesuffix('\n\n')
 
     expected = f"""
 a + 1{trampolines}
@@ -54,7 +51,7 @@ def foo(a: List[int]) -> int:
     return 1
 """
 
-    expected = trampoline_impl.removesuffix('\n\n') + yield_from_trampoline_impl.removesuffix('\n\n') + """
+    expected = trampoline_impl.removesuffix('\n\n') + """
 def x_foo__mutmut_orig(a: List[int]) -> int:
     return 1
 def x_foo__mutmut_1(a: List[int]) -> int: