🚨 ✔️ Implementing tests

tests/test_find.py

@@ -1,29 +1,35 @@
-from .utilities import base  # noqa: E261,F401
-from .test_pull import pull_massive
+from .utilities import Basic, fixture  # noqa: E261,F401
+from .test_init import InitTester
+from .test_pull import PullTester
 from snakypy.dotctrl.utils.decorators import assign_cli
 from snakypy.dotctrl.actions.find import FindCommand
 
 
-def find_element(base):  # noqa: F811
-    args = base["Menu"].args(argv=["find", f"--name={base['elements'][0]}"])
-    args_not = base["Menu"].args(argv=["find", "--name=notexists.txt"])
+class FindTester(Basic):
+    def __init__(self, fixt):
+        Basic.__init__(self, fixt)
 
-    @assign_cli(args, "find")
-    def wrapper():
-        pull_massive(base)
+    def find(self, elem):
+        return self.menu.args(argv=["find", f"--name={elem}"])
 
-        out = FindCommand(base["root"], base["home"]).main(args)
+    def run(self, elem):
+        @assign_cli(self.find(elem), "find")
+        def wrapper():
+            output = FindCommand(self.root, self.home).main(self.find(elem))
 
-        if out["code"] != "03":
-            assert False
+            if output["code"] != "03":
+                assert False
 
-        out = FindCommand(base["root"], base["home"]).main(args_not)
+            output = FindCommand(self.root, self.home).main(self.find("notexists.txt"))
 
-        if out["code"] != "04":
-            assert False
+            if output["code"] != "04":
+                assert False
 
-    return wrapper()
+        return wrapper()
 
 
-def test_find_element(base):  # noqa: F811
-    find_element(base)
+def test_find(fixture):  # noqa: F811
+    InitTester(fixture).run()
+    PullTester(fixture).massive()
+    find = FindTester(fixture)
+    find.run(find.elements[0])

tests/test_init.py

@@ -3,33 +3,35 @@
 from snakypy.dotctrl.utils.decorators import assign_cli
 from snakypy.dotctrl.actions.init import InitCommand
 
-from .utilities import base  # noqa: E261, F401
+from .utilities import Basic, fixture  # noqa: E261, F401
 
 
-def test_init(base):  # noqa: F811
-    args = base["Menu"].args(argv=["init"])
+class InitTester(Basic):
+    def __init__(self, fixt):  # noqa: F811
+        Basic.__init__(self, fixt)
 
-    @assign_cli(args, "init")
-    def wrapper():
-        InitCommand(base["root"], base["home"]).main(args)
+    @property
+    def args(self):
+        return self.menu.args(argv=["init"])
 
-        if not exists(base["Base"].config_path):
-            assert False
+    def run(self):
+        @assign_cli(self.args, "init")
+        def wrapper():
 
-        if not exists(base["Base"].repo_path):
-            assert False
+            output = InitCommand(self.root, self.home).main(self.args)
 
-    return wrapper()
+            if not exists(self.base.config_path):
+                assert False
 
+            if not exists(self.base.repo_path):
+                assert False
 
-# WHITOUT DECORATOR
-# def test_init_command(base):  # noqa: F811
+            if output["code"] != "10":
+                assert False
 
-#     args = base["Menu"].args(argv=["init"])
-#     InitCommand(base["root"], base["home"]).main(args)
+        return wrapper()
 
-#     if not exists(base["Base"].config_path):
-#         assert False
 
-#     if not exists(base["Base"].repo_path):
-#         assert False
+def test_init(fixture):  # noqa: F811
+    init = InitTester(fixture)
+    init.run()

tests/test_link.py

@@ -1,5 +1,6 @@
-from .utilities import base  # noqa: E261,F401
-from .test_pull import pull_massive
+from .utilities import Basic, fixture  # noqa: E261,F401
+from .test_pull import PullTester
+from .test_init import InitTester
 from snakypy.dotctrl.actions.link import LinkCommand
 from snakypy.dotctrl.utils.decorators import assign_cli
 from os.path import join
@@ -8,106 +9,96 @@
 from os import remove, symlink
 
 
-def link_massive(base):  # noqa: F811
-    args = base["Menu"].args(argv=["link"])
-    args_f = base["Menu"].args(argv=["link", "--f"])
+class LinkTester(Basic):
+    def __init__(self, fixt):  # noqa: F811
+        Basic.__init__(self, fixt)
 
-    pull_massive(base)
+    @property
+    def link(self):
+        return self.menu.args(argv=["link"])
 
-    @assign_cli(args, "link")
-    def wrapper():
+    def __element(self, elem):
+        return self.menu.args(argv=["link", f"--e={elem}"])
 
-        out = LinkCommand(base["root"], base["home"]).main(args)
+    def __element_force(self, elem):
+        return self.menu.args(argv=["link", f"--e={elem}", "--f"])
 
-        if not out["status"]:
-            assert False
+    def massive(self):
+        @assign_cli(self.link, "link")
+        def wrapper():
 
-        for e in base["elements"]:
-            elem_home = join(base["home"], e)
-            elem_repo = join(base["Base"].repo_path, e)
+            output = LinkCommand(self.root, self.home).main(self.link)
 
-            if not is_repo_symbolic_link(elem_home, elem_repo):
+            if not output["status"]:
                 assert False
 
-        if out["code"] != "15":
-            assert False
-
-        # # Checking for error if there are two elements with the same name in
-        # # the source and destination location.
-        remove(elem_home)
-
-        copyfile(elem_repo, elem_home)
-
-        out = LinkCommand(base["root"], base["home"]).main(args)
-
-        if not out["code"] == "27":
-            assert False
-
-        # # Using option --force (--f)
-        out = LinkCommand(base["root"], base["home"]).main(args_f)
-
-        if not is_repo_symbolic_link(elem_home, elem_repo):
-            assert False
-
-    return wrapper()
-
+            for e in self.elements:
+                elem_home = join(self.home, e)
+                elem_repo = join(self.base.repo_path, e)
 
-def link_element(base):  # noqa: F811
-    args = base["Menu"].args(argv=["link", f"--e={base['elements'][0]}"])
-    args_f = base["Menu"].args(argv=["link", f"--e={base['elements'][0]}", "--f"])
+                if not is_repo_symbolic_link(elem_home, elem_repo):
+                    assert False
 
-    pull_massive(base)
+            if output["code"] != "15":
+                assert False
 
-    @assign_cli(args, "link")
-    def wrapper():
+        return wrapper()
 
-        out = LinkCommand(base["root"], base["home"]).main(args)
+    def specific_element(self, elem):
+        @assign_cli(self.__element(elem), "link")
+        def wrapper():
 
-        if not out["status"]:
-            assert False
+            output = LinkCommand(self.root, self.home).main(self.__element(elem))
 
-        elem_home = join(base["home"], base["elements"][0])
-        elem_repo = join(base["Base"].repo_path, base["elements"][0])
+            if not output["status"]:
+                assert False
 
-        if not is_repo_symbolic_link(elem_home, elem_repo):
-            assert False
+            elem_home = join(self.home, elem)
+            elem_repo = join(self.base.repo_path, elem)
 
-        # # Checking for error if there are two elements with the same name in
-        # # the source and destination location.
-        remove(elem_home)
+            if not is_repo_symbolic_link(elem_home, elem_repo):
+                assert False
 
-        # Copy file repo to origin
-        copyfile(elem_repo, elem_home)
+            # # Checking for error if there are two elements with the same name in
+            # # the source and destination location.
+            remove(elem_home)
 
-        out = LinkCommand(base["root"], base["home"]).main(args)
+            # Copy file repo to origin
+            copyfile(elem_repo, elem_home)
 
-        if not out["code"] == "27":
-            assert False
+            output = LinkCommand(self.root, self.home).main(self.__element(elem))
 
-        # # Creating intrusive symbolic link to force an error.
-        remove(elem_home)
+            if not output["code"] == "27":
+                assert False
 
-        intruder = join(base["home"], "intruder.txt")
+            # # Creating intrusive symbolic link to force an error.
+            remove(elem_home)
 
-        symlink(intruder, join(base["home"], base["elements"][0]))
+            symlink(join(self.home, "foo.txt"), join(self.home, elem))
 
-        out = LinkCommand(base["root"], base["home"]).main(args)
+            output = LinkCommand(self.root, self.home).main(self.__element(elem))
 
-        if not out["code"] == "39":
-            assert False
+            if not output["code"] == "39":
+                assert False
 
-        # # Using option --force (--f)
-        out = LinkCommand(base["root"], base["home"]).main(args_f)
+            # # # Using option --force (--f)
+            output = LinkCommand(self.root, self.home).main(self.__element_force(elem))
 
-        if not is_repo_symbolic_link(elem_home, elem_repo):
-            assert False
+            if not is_repo_symbolic_link(elem_home, elem_repo):
+                assert False
 
-    return wrapper()
+        return wrapper()
 
 
-def test_link_massive(base):  # noqa: F811
-    link_massive(base)
+def test_link_massive(fixture):  # noqa: F811
+    InitTester(fixture).run()
+    PullTester(fixture).massive()
+    link = LinkTester(fixture)
+    link.massive()
 
 
-def test_link_element(base):  # noqa: F811
-    link_element(base)
+def test_link_specific_element(fixture):  # noqa: F811
+    InitTester(fixture).run()
+    PullTester(fixture).massive()
+    link = LinkTester(fixture)
+    link.specific_element(link.elements[0])