Esempio n. 1
0
    def test_sanity(self):  # pylint: disable=invalid-name
        fic = pf.FunctionImplementationChange()
        fp1 = pf.FunctionPyfference(name="function",
                                    implementation={fic},
                                    old_name="old_function")
        assert fp1.name == "function"
        assert fp1.implementation == {fic}
        assert fp1.old_name == "old_function"

        fp2 = pf.FunctionPyfference(name="function", implementation={fic})
        assert fp2.name == "function"
        assert fp2.implementation == {fic}
        assert fp2.old_name is None
Esempio n. 2
0
    def test_simplify(self):
        fic = pf.FunctionImplementationChange()
        change = pf.FunctionPyfference(name="function", implementation={fic})
        assert change.simplify() is change

        empty_change = pf.FunctionPyfference(name="function",
                                             implementation=set())
        assert empty_change.simplify() is None

        name_change = pf.FunctionPyfference(name="function",
                                            implementation=set(),
                                            old_name="funktion")
        assert name_change.simplify() is name_change
Esempio n. 3
0
 def test_sanity(self):
     old = parse_imports("import four; from five import six, seven")
     new = parse_imports("import one, two, three; "
                         "from module import fst, snd; "
                         "from five import seven; "
                         "from eight import nine")
     imports = pi.ImportedNames.compare(old, new)
     functions = pf.FunctionsPyfference(
         new={
             "function":
             pf.FunctionSummary("function",
                                node=Mock(spec=ast.FunctionDef)),
             "funktion":
             pf.FunctionSummary("funktion",
                                node=Mock(spec=ast.FunctionDef)),
         },
         changed={
             "name":
             pf.FunctionPyfference("name",
                                   old_name="old_name",
                                   implementation=set())
         },
         removed={},
     )
     classes = pc.ClassesPyfference(new={"NewClass2", "NewClass"},
                                    changed=set())
     change = pm.ModulePyfference(imports, classes, functions)
     assert change.classes is not None
     assert change.functions is not None
     assert change.imports is not None
     assert str(change) == (
         "Removed import of package ``four''\n"
         "New imported packages ``one'', ``three'', ``two''\n"
         "Removed import of ``six'' from ``five''\n"
         "New imported ``fst'', ``snd'' from new ``module''\n"
         "New imported ``nine'' from new ``eight''\n"
         "New NewClass\n"
         "New NewClass2\n"
         "Function ``old_name'' renamed to ``name''\n"
         "New function ``function''\n"
         "New function ``funktion''")
     assert change.simplify() is change
Esempio n. 4
0
 def test_sanity(self):
     mocked_node = Mock(spec=ast.FunctionDef)
     new = {
         "function": pf.FunctionSummary("function", node=mocked_node),
         "funktion": pf.FunctionSummary("funktion", node=mocked_node),
     }
     changed = {
         "another":
         pf.FunctionPyfference("another",
                               old_name="old_another",
                               implementation=set())
     }
     removed = {
         "gone": pf.FunctionSummary("gone", node=mocked_node),
         "for_good": pf.FunctionSummary("for_good", node=mocked_node),
     }
     change = pf.FunctionsPyfference(new=new,
                                     changed=changed,
                                     removed=removed)
     assert change.new["function"] == pf.FunctionSummary("function",
                                                         node=mocked_node)
     assert change.new["funktion"] == pf.FunctionSummary("funktion",
                                                         node=mocked_node)
     assert change.removed["gone"] == pf.FunctionSummary("gone",
                                                         node=mocked_node)
     assert change.removed["for_good"] == pf.FunctionSummary(
         "for_good", node=mocked_node)
     assert change.changed["another"].old_name == "old_another"
     assert str(change) == (
         "Removed function ``for_good''\n"
         "Removed function ``gone''\n"
         "Function ``old_another'' renamed to ``another''\n"
         "New function ``function''\n"
         "New function ``funktion''")
     change.set_method()
     assert str(change) == (
         "Removed method ``for_good''\n"
         "Removed method ``gone''\n"
         "Method ``old_another'' renamed to ``another''\n"
         "New method ``function''\n"
         "New method ``funktion''")
Esempio n. 5
0
 def test_name_change(self):
     change = pf.FunctionPyfference(name="function",
                                    implementation=set(),
                                    old_name="funktion")
     assert str(change) == "Function ``funktion'' renamed to ``function''"
Esempio n. 6
0
 def test_implementation_change(self):
     fic = pf.FunctionImplementationChange()
     change = pf.FunctionPyfference(name="function", implementation={fic})
     assert (
         str(change) == "Function ``function'' changed implementation:\n"
         "  Code semantics changed")