mutmut 3.0.2__tar.gz → 3.0.3__tar.gz

{mutmut-3.0.2 → mutmut-3.0.3}/HISTORY.rst

@@ -1,6 +1,13 @@
 Changelog
 ---------
 
+3.0.3
+~~~~~
+
+* Fixed missing requirement in install package
+
+* Fixed missing file from the install package
+
 3.0.2
 ~~~~~
 

{mutmut-3.0.2 → mutmut-3.0.3}/MANIFEST.in

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

{mutmut-3.0.2 → mutmut-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mutmut
-Version: 3.0.2
+Version: 3.0.3
 Summary: mutation testing for Python 3
 Home-page: https://github.com/boxed/mutmut
 Author: Anders Hovmöller
@@ -19,6 +19,7 @@ Requires-Dist: parso
 Requires-Dist: click
 Requires-Dist: junit-xml==1.8
 Requires-Dist: setproctitle
+Requires-Dist: textual
 Provides-Extra: pytest
 Requires-Dist: pytest; extra == "pytest"
 Provides-Extra: coverage

{mutmut-3.0.2 → mutmut-3.0.3}/mutmut/__init__.py

@@ -4,7 +4,7 @@ from parso.python.tree import (
     Number,
 )
 
-__version__ = '3.0.2'
+__version__ = '3.0.3'
 
 
 # We have a global whitelist for constants of the pattern __all__, __version__, etc

{mutmut-3.0.2 → mutmut-3.0.3}/mutmut.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mutmut
-Version: 3.0.2
+Version: 3.0.3
 Summary: mutation testing for Python 3
 Home-page: https://github.com/boxed/mutmut
 Author: Anders Hovmöller
@@ -19,6 +19,7 @@ Requires-Dist: parso
 Requires-Dist: click
 Requires-Dist: junit-xml==1.8
 Requires-Dist: setproctitle
+Requires-Dist: textual
 Provides-Extra: pytest
 Requires-Dist: pytest; extra == "pytest"
 Provides-Extra: coverage

{mutmut-3.0.2 → mutmut-3.0.3}/mutmut.egg-info/SOURCES.txt

@@ -6,11 +6,8 @@ README.rst
 requirements.txt
 setup.cfg
 setup.py
-test_requirements.txt
 ./mutmut/__init__.py
 ./mutmut/__main__.py
-mutmut/__init__.py
-mutmut/__main__.py
 mutmut/result_browser_layout.tcss
 mutmut.egg-info/PKG-INFO
 mutmut.egg-info/SOURCES.txt
@@ -18,6 +15,4 @@ mutmut.egg-info/dependency_links.txt
 mutmut.egg-info/entry_points.txt
 mutmut.egg-info/not-zip-safe
 mutmut.egg-info/requires.txt
-mutmut.egg-info/top_level.txt
-tests/test_mutation.py
-tests/test_mutmut3.py
+mutmut.egg-info/top_level.txt

{mutmut-3.0.2 → mutmut-3.0.3}/mutmut.egg-info/requires.txt

@@ -2,6 +2,7 @@ parso
 click
 junit-xml==1.8
 setproctitle
+textual
 
 [coverage]
 coverage

{mutmut-3.0.2 → mutmut-3.0.3}/requirements.txt

@@ -2,3 +2,4 @@ parso
 click
 junit-xml==1.8
 setproctitle
+textual

mutmut-3.0.2/test_requirements.txt

@@ -1,4 +0,0 @@
-pytest
-mock>=2.0.0
-coverage
-whatthepatch==0.0.6

mutmut-3.0.2/tests/test_mutation.py

@@ -1,339 +0,0 @@
-from io import StringIO
-
-import pytest
-from parso import parse
-
-from mutmut.__main__ import (
-    CLASS_NAME_SEPARATOR,
-    FuncContext,
-    get_diff_for_mutant,
-    mangle_function_name,
-    orig_function_and_class_names_from_key,
-    pragma_no_mutate_lines,
-    write_all_mutants_to_file,
-    yield_mutants_for_module,
-    yield_mutants_for_node,
-)
-
-
-@pytest.mark.parametrize(
-    'original, expected', [
-        ('foo(a, *args, **kwargs)', [
-            'foo( *args, **kwargs)',
-            'foo(None, *args, **kwargs)',
-            'foo(a, **kwargs)',
-            'foo(a, *args,)',
-        ]),
-        # TODO: Fix these
-        # ('break', 'continue'),  # probably a bad idea. Can introduce infinite loops.
-        ('a(b)', 'a(None)'),
-        # ("x if a else b", "x if a else b"),
-        ("dict(a=None)", ["dict(aXX=None)"]),
-        ("dict(a=b)", ["dict(aXX=b)", 'dict(a=None)']),
-        ('lambda **kwargs: Variable.integer(**setdefaults(kwargs, dict(show=False)))', [
-            'lambda **kwargs: Variable.integer(**setdefaults(kwargs, dict(show=True)))',
-            'lambda **kwargs: Variable.integer(**setdefaults(kwargs, dict(showXX=False)))',
-            'lambda **kwargs: Variable.integer(**setdefaults(None, dict(show=False)))',
-            'lambda **kwargs: Variable.integer(**setdefaults( dict(show=False)))',
-            # TODO: this mutant should exist... I guess we need to handle method calls separately from function calls?
-            # 'lambda **kwargs: Variable.integer()',
-            'lambda **kwargs: None',
-        ]),
-        ('a: Optional[int] = None', 'a: Optional[int] = ""'),
-        ('a: int = 1', ['a: int = 2', 'a: int = 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']),
-        ('1', '2'),
-        ('1-1', ['2-1', '1+1', '1-2']),
-        ('1*1', ['2*1', '1/1', '1*2']),
-        ('1/1', ['2/1', '1*1', '1/2']),
-        # ('1.0', '1.0000000000000002'),  # using numpy features
-        ('1.0', '2.0'),
-        ('0.1', '1.1'),
-        ('1e-3', '1.001'),
-        ('True', 'False'),
-        ('False', 'True'),
-        ('"foo"', '"XXfooXX"'),
-        ("'foo'", "'XXfooXX'"),
-        ("u'foo'", "u'XXfooXX'"),
-        ("0", "1"),
-        ("0o0", "1"),
-        ("0.", "1.0"),
-        ("0x0", "1"),
-        ("0b0", "1"),
-        ("1<2", ['2<2', '1<=2', '1<3']),
-        ('(1, 2)', ['(2, 2)', '(1, 3)']),
-        ("1 not in (1, 2)", ['2 not in (1, 2)', '1  in (1, 2)', '1 not in (2, 2)', '1 not in (1, 3)']),  # two spaces here because "not in" is two words
-        ("foo is foo", "foo is not foo"),
-        ("foo is not foo", "foo is  foo"),
-        ('a or b', 'a and b'),
-        ('a and b', 'a or b'),
-        ('a = b', 'a = None'),
-        ('a = b = c = x', 'a = b = c = None'),
-
-        # subscript
-        ('a[None]', []),
-        ('a[b]', 'a[None]'),
-        ('s[0]', ['s[1]', 's[None]']),
-        ('s[0] = a', ['s[1] = a', 's[None] = a', 's[0] = None']),
-        ('s[1:]', ['s[2:]', 's[None]']),
-
-        ('1j', '2j'),
-        ('1.0j', '2.0j'),
-        ('0o1', '2'),
-        ('1.0e10', '10000000001.0'),
-        ('a = {x for x in y}', 'a = None'),
-        ('x+=1', ['x=1', 'x-=1', 'x+=2']),
-        ('x-=1', ['x=1', 'x+=1', 'x-=2']),
-        ('x*=1', ['x=1', 'x/=1', 'x*=2']),
-        ('x/=1', ['x=1', 'x*=1', 'x/=2']),
-        ('x//=1', ['x=1', 'x/=1', 'x//=2']),
-        ('x%=1', ['x=1', 'x/=1', 'x%=2']),
-        ('x<<=1', ['x=1', 'x>>=1', 'x<<=2']),
-        ('x>>=1', ['x=1', 'x<<=1', 'x>>=2']),
-        ('x&=1', ['x=1', 'x|=1', 'x&=2']),
-        ('x|=1', ['x=1', 'x&=1', 'x|=2']),
-        ('x^=1', ['x=1', 'x&=1', 'x^=2']),
-        ('x**=1', ['x=1', 'x*=1', 'x**=2']),
-        ('def foo(s: Int = 1): pass', 'def foo(s: Int = 2): pass'),
-        ('a = None', 'a = ""'),
-        ('lambda **kwargs: None', 'lambda **kwargs: 0'),
-        ('lambda: None', 'lambda: 0'),
-        ('def foo(s: str): pass', []),
-        ('def foo(a, *, b): pass', []),
-        ('a(None)', []),
-        ("'''foo'''", []),  # don't mutate things we assume to be docstrings
-        ("r'''foo'''", []),  # don't mutate things we assume to be docstrings
-        ('(x for x in [])', []),  # don't mutate 'in' in generators
-        ("DictSynonym(a=b)", ["DictSynonym(aXX=b)", 'DictSynonym(a=None)']),
-        ("NotADictSynonym(a=b)", "NotADictSynonym(a=None)"),
-        ('from foo import *', []),
-        ('from .foo import *', []),
-        ('import foo', []),
-        ('import foo as bar', []),
-        ('foo.bar', []),
-        ('for x in y: pass', []),
-        ('def foo(a, *args, **kwargs): pass', []),
-        ('import foo', []),
-        ('isinstance(a, b)', []),
-        ('len(a)', []),
-    ]
-)
-def test_basic_mutations(original, expected):
-    if isinstance(expected, str):
-        expected = [expected]
-    func_node = parse(f'def fake():\n    {original}').children[0]
-    node = func_node.children[-1]
-    assert node.get_code().strip() == original.strip()
-    mutants = list(yield_mutants_for_node(func_node=func_node, context=FuncContext(dict_synonyms={'DictSynonym'}), node=node))
-    actual = sorted([
-        parse(mutant).children[0].children[-1].get_code().strip()
-        for (type_, mutant, _, _) in mutants
-        if type_ == 'mutant'
-    ])
-    expected = sorted(expected)
-    assert actual == expected
-
-
-def test_do_not_mutate_annotations():
-    source = """
-def foo() -> int:
-    bar: Optional[int]
-    return
-    """.strip()
-
-    mutants = [
-        mutant
-        for type_, mutant, _, _ in yield_mutants_for_module(parse(source), {})
-        if type_ == 'mutant'
-    ]
-    for m in mutants:
-        print(m)  # pragma: no cover
-
-    assert not mutants
-
-
-def test_basic_class():
-    source = """
-class Foo:
-    def member(self):        
-        return 1
-    """.strip()
-
-    mutants = [
-        mutant
-        for type_, mutant, _, _ in yield_mutants_for_module(parse(source), {})
-        if type_ == 'mutant'
-    ]
-    for m in mutants:
-        print(m)
-
-    assert len(mutants) == 1
-    assert mutants[0] == f'    def x{CLASS_NAME_SEPARATOR}Foo{CLASS_NAME_SEPARATOR}member__mutmut_1(self):        \n        return 2'
-
-
-def mutants_for_source(source):
-    no_mutate_lines = pragma_no_mutate_lines(source)
-    r = []
-    for type_, x, name_and_hash, mutant_name in yield_mutants_for_module(parse(source, error_recovery=False), no_mutate_lines):
-        if type_ == 'mutant':
-            r.append(x)
-    return r
-
-
-def test_function_with_annotation():
-    source = "def capitalize(s : str):\n    return s[0].upper() + s[1:] if s else s\n".strip()
-    mutants = mutants_for_source(source)
-    assert mutants == [
-        'def capitalize__mutmut_1(s : str):\n    return s[1].upper() + s[1:] if s else s',
-        'def capitalize__mutmut_2(s : str):\n    return s[None].upper() + s[1:] if s else s',
-        'def capitalize__mutmut_3(s : str):\n    return s[0].upper() - s[1:] if s else s',
-        'def capitalize__mutmut_4(s : str):\n    return s[0].upper() + s[2:] if s else s',
-        'def capitalize__mutmut_5(s : str):\n    return s[0].upper() + s[None] if s else s'
-    ]
-
-
-def test_pragma_no_mutate():
-    source = """def foo():\n    return 1+1  # pragma: no mutate\n""".strip()
-    mutants = mutants_for_source(source)
-    assert not mutants
-
-
-def test_pragma_no_mutate_and_no_cover():
-    source = """def foo():\n    return 1+1  # pragma: no cover, no mutate\n""".strip()
-    mutants = mutants_for_source(source)
-    assert not mutants
-
-
-def test_mutate_dict():
-    source = '''
-def foo():    
-    dict(a=b, c=d)
-'''
-    mutants = mutants_for_source(source)
-    assert mutants == [
-        '\ndef foo__mutmut_1():    \n    dict(a=None, c=d)\n',
-        '\ndef foo__mutmut_2():    \n    dict(aXX=b, c=d)\n',
-        '\ndef foo__mutmut_3():    \n    dict(a=b, c=None)\n',
-        '\ndef foo__mutmut_4():    \n    dict(a=b, cXX=d)\n',
-        '\ndef foo__mutmut_5():    \n    dict( c=d)\n',
-        '\ndef foo__mutmut_6():    \n    dict(a=b,)\n',
-    ]
-
-
-def test_syntax_error():
-    with pytest.raises(Exception):
-        mutants_for_source(':!')
-
-
-def test_bug_github_issue_18():
-    source = """
-@register.simple_tag(name='icon')
-def icon(name):
-    if name is None:
-        return ''
-    tpl = '<span class="glyphicon glyphicon-{}"></span>'
-    return format_html(tpl, name)
-    """.strip()
-    mutants_for_source(source)
-
-
-def test_bug_github_issue_19_argument_mutation_crash():
-    source = """key = lambda a: "foo"
-filters = dict((key(field), False) for field in fields)"""
-    mutants_for_source(source)
-
-
-def test_bug_github_issue_26():
-    source = """
-def wrapper():
-    class ConfigurationOptions(Protocol):
-        min_name_length: int
-    """.strip()
-    assert mutants_for_source(source) == []
-
-
-def test_bug_github_issue_30():
-    source = """
-def wrapper():
-    def from_checker(cls: Type['BaseVisitor'], checker) -> 'BaseVisitor':
-        pass
-    """.strip()
-    assert mutants_for_source(source) == []
-
-
-def test_bug_github_issue_77():
-    # Don't crash on this
-    assert mutants_for_source('') == []
-
-
-def test_multiline_dunder_whitelist():
-    source = """
-__all__ = [
-    1,
-    2,
-    'foo',
-    'bar',
-]
-    """.strip()
-    mutants = mutants_for_source(source)
-    assert not mutants
-
-
-def test_bad_mutation_str_type_definition():
-    source = """
-def foo():
-    foo: 'SomeType'
-""".strip()
-    mutants = mutants_for_source(source)
-    assert not mutants
-
-
-def test_orig_function_name_from_key():
-    assert orig_function_and_class_names_from_key(f'_{CLASS_NAME_SEPARATOR}Foo{CLASS_NAME_SEPARATOR}bar__mutmut_1') == ('bar', 'Foo')
-    assert orig_function_and_class_names_from_key('bar__mutmut_1') == ('bar', None)
-
-
-def test_mangle_function_name():
-    assert mangle_function_name(name='bar', class_name=None) == 'bar'
-    assert mangle_function_name(name='bar', class_name='Foo') == f'x{CLASS_NAME_SEPARATOR}Foo{CLASS_NAME_SEPARATOR}bar'
-
-
-def test_diff_ops():
-    source = """
-def foo():    
-    return 1
-
-
-class Foo:
-    def member(self):        
-        return 3
-
-    """.strip()
-
-    out = StringIO()
-    mutant_names, hash_by_function_name = write_all_mutants_to_file(out=out, source=source, filename='filename')
-    assert len(mutant_names) == 2
-    mutants_source = out.getvalue()
-
-    diff1 = get_diff_for_mutant(mutant_name=mutant_names[0], source=mutants_source, path='test.py').strip()
-    diff2 = get_diff_for_mutant(mutant_name=mutant_names[1], source=mutants_source, path='test.py').strip()
-
-    assert diff1 == '''
---- test.py
-+++ test.py
-@@ -1,2 +1,2 @@
- def foo():    
--    return 1
-+    return 2
-'''.strip()
-
-    assert diff2 == '''
---- test.py
-+++ test.py
-@@ -1,2 +1,2 @@
- def member(self):        
--        return 3
-+        return 4
-'''.strip()

mutmut-3.0.2/tests/test_mutmut3.py

@@ -1,80 +0,0 @@
-from parso import parse
-
-from mutmut.__main__ import (
-    trampoline_impl,
-    yield_mutants_for_module,
-)
-
-
-def test_yield_mutants_for_module():
-    source = """
-a + 1
-
-def foo(a, b, c):
-    return a + b * c
-"""
-
-    expected = trampoline_impl + """
-
-a + 1
-
-def foo__mutmut_orig(a, b, c):
-    return a + b * c
-
-def foo__mutmut_1(a, b, c):
-    return a - b * c
-
-def foo__mutmut_2(a, b, c):
-    return a + b / c
-
-foo__mutmut_mutants = {
-'foo__mutmut_1': foo__mutmut_1, 
-    'foo__mutmut_2': foo__mutmut_2
-}
-
-def foo(*args, **kwargs):
-    return _mutmut_trampoline(foo__mutmut_orig, foo__mutmut_mutants, *args, **kwargs) 
-
-foo.__signature__ = _mutmut_signature(foo__mutmut_orig)
-foo__mutmut_orig.__name__ = 'foo'
-
-
-"""
-
-    node = parse(source)
-    result = ''.join([x[1] for x in yield_mutants_for_module(node, no_mutate_lines=[])])
-
-    assert result == expected
-
-
-def test_avoid_annotations():
-    source = """
-def foo(a: List[int]) -> int:
-    return 1
-"""
-
-    expected = trampoline_impl + """
-
-def foo__mutmut_orig(a: List[int]) -> int:
-    return 1
-
-def foo__mutmut_1(a: List[int]) -> int:
-    return 2
-
-foo__mutmut_mutants = {
-'foo__mutmut_1': foo__mutmut_1
-}
-
-def foo(*args, **kwargs):
-    return _mutmut_trampoline(foo__mutmut_orig, foo__mutmut_mutants, *args, **kwargs) 
-
-foo.__signature__ = _mutmut_signature(foo__mutmut_orig)
-foo__mutmut_orig.__name__ = 'foo'
-
-
-"""
-
-    node = parse(source)
-    result = ''.join([x[1] for x in yield_mutants_for_module(node, no_mutate_lines=[])])
-
-    assert result == expected