mutmut 2.4.4__tar.gz → 3.2.3__tar.gz

{mutmut-2.4.4 → mutmut-3.2.3}/AUTHORS.rst

@@ -2,7 +2,7 @@
 Credits
 =======
 
-* Anders Hovmöller <anders.hovmoller@trioptima.com>
+* Anders Hovmöller <boxed@killingar.net>
 * Felipe Pontes <felipemfpontes@gmail.com>
 * William Orr <will@worrbase.com>
 * Trevin Gandhi <trevin.gandhi@petuum.com>
@@ -20,11 +20,4 @@ Credits
 * Emil Stenström <emil@emilstenstrom.se>
 * Roxane Bellott <roxane.bellot@gmail.com>
 * Tomáš Chvátal <tchvatal@suse.com>
-* Felix Divo <https://github.com/felixdivo>
-* Andreas Finkler <andi.finkler@gmail.com>
-* sed-i
-* Peter Hill <peter.hill@york.ac.uk>
-* Samuel Razzell <srazzell@apple.com>
-* Daniel Versoza Alves <daniel.alves@voxy.com>
-* Zac Hatfield-Dodds <zac.hatfield.dodds@gmail.com>
-* Jan Królikowski <yanekk86@gmail.com>
+* Frank Hoffmann <15r10nk-git@polarbit.de>

{mutmut-2.4.4 → mutmut-3.2.3}/HISTORY.rst

@@ -1,102 +1,104 @@
 Changelog
 ---------
 
-2.4.4
+3.2.3
 ~~~~~
 
-* Fix issue with `TypeError` for empty file diffs
+* Crash with error message on invalid imports for `src` module
 
-* Introduce mutation of f-strings
+* Autodetect simpler project configurations with `test_*.py` in the dir directly
 
-* Allow newer versions of junit-xml
+* Handle filenames (as opposed to dirnames) in paths_to_mutate
 
-2.4.3
-~~~~~
+* Also copy `setup.cfg` and `pyproject.toml` by default
 
-* Fix for a big where worker cycling would just hang mutmut (thanks Jan Królikowski!)
+* Handle single line `paths_to_mutate`
 
-* Added `--CI` flag
 
+3.2.2
+~~~~~
 
+* Fixed crash when running `mutmut results`
 
-2.4.2
+3.2.1
 ~~~~~
 
-* Fix bug with init db on wrong function (thanks Samuel Razzell)
-
-* Fixed junitxml line number, daemon warning, and missing argument in unit test (thanks Samuel Razzell)
+* Read `paths_to_mutate` from config file
 
+* Mutate `break` to `return` to avoid timeouts
 
-2.4.1
-~~~~~
+* Added debug mode. Enable with `debug=True` in `setup.cfg` under `[mutmut]`
 
-* Support paths with path separators
+* Fixed new test detection. The old code incorrectly detected new tests when there were none, creating a much slower interaction loop for fixing mutants.
 
-* Disable spinner in no-progress mode
+* And many more fixes
 
-2.4.0
+3.2.0
 ~~~~~
 
-* Add pyproject support (thanks sed-i)
+* Timeouts for mutants implemented.
+
+* Browser: syntax highlighting for diff view
 
-* Change very small or very large numbers (floats) by a relative amount (thanks Peter Hill)
+* More fixes for generators.
 
-    This avoids (some) problems with unkillable mutants, for example:
+* Fix for `src`-style layout of projects.
 
-        1e16 -> 1e+16
+* Fixed bug where mutmut would recollect all tests on every run, slowing down startup.
 
-    which now becomes
 
-        1e16 -> 2e+16
+3.1.0
+~~~~~
 
-* Fix inconsistent output of `mutmut show` after using `--enable-mutation-types` (thanks Andreas Finkler)
+* Correctly handle mutation for generator functions (`yield`).
 
-* Improve test selection through ``pre_mutation(context)`` (thanks Andreas Finkler)
+* Fixed so that `from __future__` lines are always first.
 
-* Remove `--cache-only` option and second argument to `mutmut show` (thanks Andreas Finkler)
+* If no stats are collected exit directly, as that is a breaking error for mutation testing.
 
+* Changed name mangling to make mutants less likely to trigger name-based python magic, like in pytest where functions named `test_*` have special meaning.
 
-2.3.0
+
+3.0.5
 ~~~~~
 
-* Add `--disable-mutation-types` and `--enable-mutation-types` to control what types of mutations are performed
+* Another attempt to get the pypi package to work
 
-* Fixed error where ``mutmut_config.init()`` was not called when running without explicitly having set ``PYTHONPATH``
 
-* Use ``Click``'s subcommand feature to refactor the command line interface. For the end user, this can now run ``mutmut [COMMAND] -h``
-  to check which parameters are relevant to this specific subcommand. The change is backwards compatible, and all existing commands
-  work the same as before, with the exception of ``mutmut --version``, which now has to be ``mutmut version``.
+3.0.4
+~~~~~
 
-* You can now set the ``context.config.test_command`` in the ``mutmut_config.pre_mutation(context)`` hook to select the relevant subset of tests.
-  Coverage contexts are now accessible in ``config.coverage_data`` to help with the selection.
+* Another attempt to get the pypi package to work
 
-2.2.0
+3.0.3
 ~~~~~
 
-* Add ability to update progress output only after test passes (`--no-progress`)
+* Fixed missing requirement in install package
 
-* Added option `--simple-output` to disable usage of emojis in output
+* Fixed missing file from the install package
 
-* Fixed the total mutants and killed column in html report (#184)
+3.0.2
+~~~~~
 
-* Fixed paths_to_exclude config parsing
+* Fixed bad entrypoint definition
 
-* Stricter error code check for test runners. The previous check sometimes counted no tests as a killed mutant
+* Ignore files that can't be parsed by `parso`
 
-* Misc fixes
 
-2.1.0
+3.0.1
 ~~~~~
 
-* Support unittest, so you don't need pytest anymore
+* Missed a file in distribution, so `browse` command was broken.
+
+3.0.0
+~~~~~
 
-* Fixed a bug where Ctrl+C wouldn't exit mutmut
+* Execution model switched to mutation schemata, which enabled parallell execution.
 
-* Support for Coverage 5
+* New terminal UI
 
-* Skip mutating test files if they are in the same source tree as the main code
+* Pytest only, which enabled better integration, cutting execution time significantly.
 
-* Advanced whitelisting: More advanced AST level callback
 
 2.0.0
 ~~~~~

{mutmut-2.4.4 → mutmut-3.2.3}/MANIFEST.in

@@ -2,4 +2,5 @@ include HISTORY.rst
 include LICENSE
 include README.rst
 include requirements.txt
-include test_requirements.txt
+exclude tests/*.*
+recursive-include mutmut *.*

mutmut-3.2.3/PKG-INFO

@@ -0,0 +1,215 @@
+Metadata-Version: 2.1
+Name: mutmut
+Version: 3.2.3
+Summary: mutation testing for Python 3
+Home-page: https://github.com/boxed/mutmut
+Author: Anders Hovmöller
+Author-email: boxed@killingar.net
+License: BSD
+Keywords: mutmut mutant mutation test testing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+License-File: LICENSE
+License-File: AUTHORS.rst
+Requires-Dist: parso
+Requires-Dist: click
+Requires-Dist: junit-xml==1.8
+Requires-Dist: setproctitle
+Requires-Dist: textual
+Requires-Dist: toml>=0.10.2; python_version < "3.11"
+
+mutmut - python mutation tester
+===============================
+
+.. image:: https://github.com/boxed/mutmut/actions/workflows/tests.yml/badge.svg
+    :target: https://github.com/boxed/mutmut/actions/workflows/tests.yml
+
+.. image:: https://readthedocs.org/projects/mutmut/badge/?version=latest
+    :target: https://mutmut.readthedocs.io/en/latest/?badge=latest
+    :alt: Documentation Status
+
+
+Mutmut is a mutation testing system for Python, with a strong focus on ease
+of use. If you don't know what mutation testing is try starting with
+`this article <https://kodare.net/2016/12/01/mutmut-a-python-mutation-testing-system.html>`_.
+
+Some highlight features:
+
+- Found mutants can be applied on disk with a simple command making it very
+  easy to work with the results
+- Remembers work that has been done, so you can work incrementally
+- Knows which tests to execute, speeding up mutation testing
+- Interactive terminal based UI
+- Parallel and fast execution
+
+.. image:: browse_screenshot.png
+
+
+If you want to mutate code outside of functions, you can try using mutmut 2,
+which has a different execution model than mutmut 3+.
+
+
+Requirements
+------------
+
+Mutmut must be run on a system with `fork` support. This means that if you want
+to run on windows, you must run inside WSL.
+
+
+
+Install and run
+---------------
+
+You can get started with a simple:
+
+.. code-block:: console
+
+    pip install mutmut
+    mutmut run
+
+This will by run pytest on tests in the "tests" or "test" folder and
+it will try to figure out where the code to mutate is.
+
+
+
+You can stop the mutation run at any time and mutmut will restart where you
+left off. It will continue where it left off, and re-test functions that were
+modified since last run.
+
+To work with the results, use `mutmut browse` where you can see the mutants,
+retest them when you've updated your tests.
+
+You can also write a mutant to disk from the `browse` interface, or via
+`mutmut apply <mutant>`. You should **REALLY** have the file you mutate under
+source code control and committed before you apply a mutant!
+
+
+Configuration
+-------------
+
+In `setup.cfg` in the root of your project you can configure mutmut if you need to:
+
+.. code-block:: ini
+
+    [mutmut]
+    paths_to_mutate=src/
+    tests_dir=tests/
+
+See below for more options for configuring mutmut.
+
+
+Wildcards for testing mutants
+-----------------------------
+
+Unix filename pattern matching style on mutants is supported. Example:
+
+.. code-block:: console
+
+    mutmut run "my_module*"
+    mutmut run "my_module.my_function*"
+
+In the `browse` TUI you can press `f` to retest a function, and `m` to retest
+an entire module.
+
+
+"also copy" files
+-----------------
+
+To run the full test suite some files are often needed above the tests and the
+source. You can configure to copy extra files that you need by adding
+directories and files to `also_copy` in your `setup.cfg`:
+
+.. code-block:: ini
+
+    also_copy=
+        iommi/snapshots/
+        conftest.py
+
+
+Limit stack depth
+-----------------
+
+In big code bases some functions are called incidentally by huge swaths of the
+codebase, but you really don't want tests that hit those executions to count
+for mutation testing purposes. Incidentally tested functions lead to slow
+mutation testing as hundreds of tests can be checked for things that should
+have clean and fast unit tests, and it leads to bad test suites as any
+introduced bug in those base functions will lead to many tests that fail which
+are hard to understand how they relate to the function with the change.
+
+You can configure mutmut to only count a test as being relevant for a function
+if the stack depth from the test to the function is below some limit. In your
+`setup.cfg` add:
+
+.. code-block:: ini
+
+    max_stack_depth=8
+
+A lower value will increase mutation speed and lead to more localized tests,
+but will also lead to more surviving mutants that would otherwise have been
+caught.
+
+
+Exclude files from mutation
+---------------------------
+
+You can exclude files from mutation in `setup.cfg`:
+
+.. code-block::
+
+    do_not_mutate=
+        *__tests.py
+
+
+Whitelisting
+------------
+
+You can mark lines like this:
+
+.. code-block:: python
+
+    some_code_here()  # pragma: no mutate
+
+to stop mutation on those lines. Some cases we've found where you need to
+whitelist lines are:
+
+- The version string on your library. You really shouldn't have a test for this :P
+- Optimizing break instead of continue. The code runs fine when mutating break
+  to continue, but it's slower.
+
+
+Example mutations
+-----------------
+
+- Integer literals are changed by adding 1. So 0 becomes 1, 5 becomes 6, etc.
+- `<` is changed to `<=`
+- break is changed to continue and vice versa
+
+In general the idea is that the mutations should be as subtle as possible.
+See `__init__.py` for the full list.
+
+
+Workflow
+--------
+
+This section describes how to work with mutmut to enhance your test suite.
+
+1. Run mutmut with `mutmut run`. A full run is preferred but if you're just
+   getting started you can exit in the middle and start working with what you
+   have found so far.
+2. Show the mutants with `mutmut browse`
+3. Find a mutant you want to work on and write a test to try to kill it.
+4. Press `r` to rerun the mutant and see if you successfully managed to kill it.
+
+Mutmut keeps the data of what it has done and the mutants in the `mutants/`
+directory.If  you want to make sure you run a full mutmut run you can delete
+this directory to start from scratch.
+
+Contributing to Mutmut
+----------------------
+
+If you wish to contribute to Mutmut, please see our `contributing guide <CONTRIBUTING.rst>`_.

mutmut-3.2.3/README.rst

@@ -0,0 +1,191 @@
+mutmut - python mutation tester
+===============================
+
+.. image:: https://github.com/boxed/mutmut/actions/workflows/tests.yml/badge.svg
+    :target: https://github.com/boxed/mutmut/actions/workflows/tests.yml
+
+.. image:: https://readthedocs.org/projects/mutmut/badge/?version=latest
+    :target: https://mutmut.readthedocs.io/en/latest/?badge=latest
+    :alt: Documentation Status
+
+
+Mutmut is a mutation testing system for Python, with a strong focus on ease
+of use. If you don't know what mutation testing is try starting with
+`this article <https://kodare.net/2016/12/01/mutmut-a-python-mutation-testing-system.html>`_.
+
+Some highlight features:
+
+- Found mutants can be applied on disk with a simple command making it very
+  easy to work with the results
+- Remembers work that has been done, so you can work incrementally
+- Knows which tests to execute, speeding up mutation testing
+- Interactive terminal based UI
+- Parallel and fast execution
+
+.. image:: browse_screenshot.png
+
+
+If you want to mutate code outside of functions, you can try using mutmut 2,
+which has a different execution model than mutmut 3+.
+
+
+Requirements
+------------
+
+Mutmut must be run on a system with `fork` support. This means that if you want
+to run on windows, you must run inside WSL.
+
+
+
+Install and run
+---------------
+
+You can get started with a simple:
+
+.. code-block:: console
+
+    pip install mutmut
+    mutmut run
+
+This will by run pytest on tests in the "tests" or "test" folder and
+it will try to figure out where the code to mutate is.
+
+
+
+You can stop the mutation run at any time and mutmut will restart where you
+left off. It will continue where it left off, and re-test functions that were
+modified since last run.
+
+To work with the results, use `mutmut browse` where you can see the mutants,
+retest them when you've updated your tests.
+
+You can also write a mutant to disk from the `browse` interface, or via
+`mutmut apply <mutant>`. You should **REALLY** have the file you mutate under
+source code control and committed before you apply a mutant!
+
+
+Configuration
+-------------
+
+In `setup.cfg` in the root of your project you can configure mutmut if you need to:
+
+.. code-block:: ini
+
+    [mutmut]
+    paths_to_mutate=src/
+    tests_dir=tests/
+
+See below for more options for configuring mutmut.
+
+
+Wildcards for testing mutants
+-----------------------------
+
+Unix filename pattern matching style on mutants is supported. Example:
+
+.. code-block:: console
+
+    mutmut run "my_module*"
+    mutmut run "my_module.my_function*"
+
+In the `browse` TUI you can press `f` to retest a function, and `m` to retest
+an entire module.
+
+
+"also copy" files
+-----------------
+
+To run the full test suite some files are often needed above the tests and the
+source. You can configure to copy extra files that you need by adding
+directories and files to `also_copy` in your `setup.cfg`:
+
+.. code-block:: ini
+
+    also_copy=
+        iommi/snapshots/
+        conftest.py
+
+
+Limit stack depth
+-----------------
+
+In big code bases some functions are called incidentally by huge swaths of the
+codebase, but you really don't want tests that hit those executions to count
+for mutation testing purposes. Incidentally tested functions lead to slow
+mutation testing as hundreds of tests can be checked for things that should
+have clean and fast unit tests, and it leads to bad test suites as any
+introduced bug in those base functions will lead to many tests that fail which
+are hard to understand how they relate to the function with the change.
+
+You can configure mutmut to only count a test as being relevant for a function
+if the stack depth from the test to the function is below some limit. In your
+`setup.cfg` add:
+
+.. code-block:: ini
+
+    max_stack_depth=8
+
+A lower value will increase mutation speed and lead to more localized tests,
+but will also lead to more surviving mutants that would otherwise have been
+caught.
+
+
+Exclude files from mutation
+---------------------------
+
+You can exclude files from mutation in `setup.cfg`:
+
+.. code-block::
+
+    do_not_mutate=
+        *__tests.py
+
+
+Whitelisting
+------------
+
+You can mark lines like this:
+
+.. code-block:: python
+
+    some_code_here()  # pragma: no mutate
+
+to stop mutation on those lines. Some cases we've found where you need to
+whitelist lines are:
+
+- The version string on your library. You really shouldn't have a test for this :P
+- Optimizing break instead of continue. The code runs fine when mutating break
+  to continue, but it's slower.
+
+
+Example mutations
+-----------------
+
+- Integer literals are changed by adding 1. So 0 becomes 1, 5 becomes 6, etc.
+- `<` is changed to `<=`
+- break is changed to continue and vice versa
+
+In general the idea is that the mutations should be as subtle as possible.
+See `__init__.py` for the full list.
+
+
+Workflow
+--------
+
+This section describes how to work with mutmut to enhance your test suite.
+
+1. Run mutmut with `mutmut run`. A full run is preferred but if you're just
+   getting started you can exit in the middle and start working with what you
+   have found so far.
+2. Show the mutants with `mutmut browse`
+3. Find a mutant you want to work on and write a test to try to kill it.
+4. Press `r` to rerun the mutant and see if you successfully managed to kill it.
+
+Mutmut keeps the data of what it has done and the mutants in the `mutants/`
+directory.If  you want to make sure you run a full mutmut run you can delete
+this directory to start from scratch.
+
+Contributing to Mutmut
+----------------------
+
+If you wish to contribute to Mutmut, please see our `contributing guide <CONTRIBUTING.rst>`_.