Cleanup backends unit tests

Author: idle-code

contextshell/backends/FilesystemTree.py

@@ -3,10 +3,9 @@
 
 from ..path import NodePath
 from ..action import action_from_function, BuiltinExecutor
-from ..exceptions import NotSupportedError
 
 
-class FilesystemRoot(BuiltinExecutor):
+class FilesystemTree(BuiltinExecutor):
     def __init__(self, root_directory_path: str):
         super().__init__()
         self.root_directory_path = Path(root_directory_path)

contextshell/backends/NodeTree.py

@@ -23,7 +23,8 @@ def get(self):
     def set(self, new_value):
         """Store provided value in this node"""
         if type(self._value) != type(new_value):
-            raise TypeError("Cannot assign value with type '{}' to '{}' node".format(type(new_value).__name__, type(self._value).__name__))
+            raise TypeError("Cannot assign value with type '{}' to '{}' node".format(type(new_value).__name__,
+                                                                                     type(self._value).__name__))
         self._value = new_value
 
     def list(self):
@@ -36,7 +37,7 @@ def list(self):
             index += 1
         return indexed_names
 
-    def append(self, node, name: str=None):
+    def append(self, node, name: str = None):
         """Append provided node as a subnode"""
         if node is None:
             raise ValueError("Cannot append None as node")
@@ -48,7 +49,7 @@ def append(self, node, name: str=None):
         node._parent = self
         self._subnodes.append((name, node))
 
-    def get_node(self, name: str=None, index: int=None) -> Optional['Node']:
+    def get_node(self, name: str = None, index: int = None) -> Optional['Node']:
         """Return subnode with provided name or index"""
         if name is not None:
             for p in self._subnodes:
@@ -71,7 +72,7 @@ def __getitem__(self, name_or_index) -> 'Node':
             raise KeyError(name_or_index)
         return node
 
-    def remove(self, name: str=None, index: int=None) -> 'Node':
+    def remove(self, name: str = None, index: int = None) -> 'Node':
         """Remove subnode with provided name"""
         node_to_remove = self.get_node(name=name, index=index)
         if node_to_remove is None:
@@ -80,7 +81,7 @@ def remove(self, name: str=None, index: int=None) -> 'Node':
         node_to_remove._parent = None
         return node_to_remove
 
-    def contains(self, name: str=None, index: int=None) -> bool:
+    def contains(self, name: str = None, index: int = None) -> bool:
         """Checks if there is a subnode with provided name"""
         return self.get_node(name=name, index=index) is not None
 
@@ -91,6 +92,7 @@ def __contains__(self, name: str):
 # CHECK: how to implement TemporaryTreeRoot (based on NodeTreeRoot)
 class NodeTreeRoot(ActionExecutor):
     """Frontend to the (passive) node-based data storage"""
+
     def __init__(self):
         self.root = self.create_node(None)
         self.install_default_actions()
@@ -200,7 +202,7 @@ def find_type(self, target: NodePath, type_name: NodePath):  # TODO: add type-hi
     def create_node(self, value):
         return Node(value)
 
-    def create(self, path: NodePath, initial_value = None):
+    def create(self, path: NodePath, initial_value=None):
         parent = self._create_path(path.base_path)
         new_node = self.create_node(initial_value)
         parent.append(new_node, path.base_name)
@@ -232,7 +234,7 @@ def _resolve_path(self, path: NodePath, root: Node = None) -> Node:
             raise NameError("'{}' doesn't exists".format(path))
         return node
 
-    def _resolve_optional_path(self, path: NodePath, root: Node=None) -> Optional[Node]:
+    def _resolve_optional_path(self, path: NodePath, root: Node = None) -> Optional[Node]:
         if root is None:
             if path.is_relative:
                 raise ValueError("Could not resolve relative paths")

tests/functional/FilesystemTests.py

@@ -4,14 +4,14 @@
 from contextshell.action import ActionExecutor
 from tests.functional.ShellTestsBase import TreeRootTestsBase
 from tests.functional.TestExecutor import script_test
-from contextshell.backends.FilesystemTree import FilesystemRoot
+from contextshell.backends.FilesystemTree import FilesystemTree
 
 
 class FilesystemTestsBase(TreeRootTestsBase):
     test_directory_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'test_data')
 
     def create_tree_root(self) -> ActionExecutor:
-        return FilesystemRoot(self.test_directory.name)
+        return FilesystemTree(self.test_directory.name)
 
     def _make_test_path(self, relative_path):
         return Path(self.test_directory.name).joinpath(relative_path)

tests/unit/Fakes.py

@@ -1,5 +1,7 @@
+from collections import OrderedDict
+
 from contextshell.path import NodePath
-from contextshell.action import Action, ActionArgsPack
+from contextshell.action import Action, ActionArgsPack, ActionExecutor
 from typing import Dict
 
 
@@ -30,3 +32,17 @@ def invoke(self, target: NodePath, action: NodePath, arguments: ActionArgsPack):
         self.received_action = action
         self.received_arguments = arguments
         return self.return_value
+
+
+class FakeActionExecutor(ActionExecutor):
+    def __init__(self):
+        self.execute_target = None
+        self.execute_action = None
+        self.execute_args = None
+        self.execute_return = None
+
+    def execute(self, target: NodePath, action: NodePath, args: ActionArgsPack = None):
+        self.execute_target = target
+        self.execute_action = action
+        self.execute_args = args if args else OrderedDict()
+        return self.execute_return

tests/unit/backends/FilesystemTreeTests.py

@@ -0,0 +1,9 @@
+import unittest
+
+from contextshell.path import NodePath as np
+
+
+def create_filesystem_tree(*args, **kwargs):
+    from contextshell.backends.FilesystemTree import FilesystemTree
+    return FilesystemTree(*args, **kwargs)
+