Refactor Shell-based test classes

Author: idle-code

.idea/ContextShell.iml

@@ -98,7 +98,7 @@ def list_actions(self, path: NodePath) -> List[NodePath]:
         else:
             return action_paths + self.list_actions(path.base_path)
 
-    def is_attribute(self, path: str): # CHECK: is used?
+    def is_attribute(self, path: str):  # CHECK: is this used/needed?
         return path.startswith('@')
 
     def install_global_type(self, node_type):
@@ -118,8 +118,10 @@ def find_type(self, target: NodePath, type_name: NodePath):  # TODO: add type-hi
             return None
         return type_node.get()
 
-    def execute(self, target: NodePath, action_name: NodePath, args: ActionArgsPack=OrderedDict()):
+    def execute(self, target: NodePath, action_name: NodePath, args: ActionArgsPack = None):
         #print("Execute: {}: {} {}".format(target, action, args))
+        if not args:
+            args = OrderedDict()
         action_impl = self.find_action(target, action_name)
         if action_impl is None:
             raise NameError("Could not find action named '{}'".format(action_name))
@@ -128,7 +130,7 @@ def execute(self, target: NodePath, action_name: NodePath, args: ActionArgsPack=
     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)

contextshell/NodeTreeRoot.py

@@ -3,21 +3,22 @@
 from typing import Dict, Union, Any, Tuple, List
 from collections import OrderedDict
 
-
-ActionArgsPack = Dict[Union[NodePath, int], Any]
-PositionalArguments = List[Any]
-KeywordArguments = Dict[str, Any]
+ArgumentValue = Any
+ActionArgsPack = Dict[Union[NodePath, int], ArgumentValue]
+PositionalArguments = List[ArgumentValue]
+KeywordArguments = Dict[str, ArgumentValue]
 
 
+# CHECK: Rename TreeRoot to ActionEndpoint or something more appropriate?
 class TreeRoot(ABC):
     @abstractmethod
-    def execute(self, target: NodePath, action: NodePath, args: ActionArgsPack=OrderedDict()):
+    def execute(self, target: NodePath, action: NodePath, args: ActionArgsPack = None):
         raise NotImplementedError()
 
 
 def unpack_argument_tree(action_args: ActionArgsPack) -> Tuple[PositionalArguments, KeywordArguments]:
-    args = dict()
-    kwargs: Dict[str, Any] = OrderedDict()
+    args: Dict[int, ArgumentValue] = dict()
+    kwargs: KeywordArguments = OrderedDict()
     for key, value in action_args.items():
         if isinstance(key, int):
             args[key] = value
@@ -29,7 +30,7 @@ def unpack_argument_tree(action_args: ActionArgsPack) -> Tuple[PositionalArgumen
 
 
 def pack_argument_tree(*args: PositionalArguments, **kwargs: KeywordArguments) -> ActionArgsPack:
-    pack_list: List[Tuple[Union[NodePath, int], Any]] = []
+    pack_list: List[Tuple[Union[NodePath, int], ArgumentValue]] = []
     for i, arg in enumerate(args):
         pack_list.append((i, arg))
     for key, value in kwargs.items():
@@ -39,7 +40,7 @@ def pack_argument_tree(*args: PositionalArguments, **kwargs: KeywordArguments) -
 
 def parse_argument_tree(raw_arguments: List[str]) -> ActionArgsPack:
     from contextshell.CommandParser import convert_token_type
-    pack_list: List[Tuple[Union[NodePath, int], Any]] = []
+    pack_list: List[Tuple[Union[NodePath, int], ArgumentValue]] = []
     for i, arg in enumerate(raw_arguments):
         if isinstance(arg, str) and '=' in arg:
             key, value = arg.split('=')

contextshell/TreeRoot.py

@@ -4,25 +4,33 @@
 
 
 class VirtualTree(TreeRoot):
+    """Abstract frontend allowing embedding (mounting) of more specific tree roots"""
+
     def __init__(self):
         self.mounts: OrderedDict[NodePath, TreeRoot] = OrderedDict()
 
+    # TODO: rename to attach/detach
     def mount(self, path: NodePath, root: TreeRoot):
         if path.is_relative:
             raise ValueError("Could not mount relative path")
         if path in self.mounts:
             raise KeyError("Path '{}' is already provided by {}".format(path, self.mounts[path]))
 
+        def path_length_extractor(path_root_pair):
+            return len(path_root_pair[0])
+
+        # CHECK: use bisect module for maintaining mount point list?
         updated_items = list(self.mounts.items()) + [(path, root)]
-        path_length_extractor = lambda pair: len(pair[0])
         self.mounts = OrderedDict(sorted(updated_items, key=path_length_extractor, reverse=True))
 
     def umount(self, path: NodePath):
         del self.mounts[path]
 
-    def execute(self, target: NodePath, action: NodePath, args: ActionArgsPack=OrderedDict()):
+    def execute(self, target: NodePath, action: NodePath, args: ActionArgsPack = None):
         if target.is_relative:
-            raise ValueError("Could not execute with relative target path")
+            raise ValueError("Could not invoke action with relative target path")
+        if not args:
+            args = OrderedDict()
         for path, root in self.mounts.items():
             if path.is_parent_of(target):
                 remapped_target = target.relative_to(path)

contextshell/VirtualTree.py

@@ -0,0 +1,10 @@
+from contextshell.TreeRoot import TreeRoot
+from contextshell.backends.Module import Module
+
+
+class FilesystemRoot(TreeRoot):
+    pass
+
+
+class FilesystemModule(Module):
+    pass

contextshell/backends/Filesystem.py

@@ -0,0 +1,8 @@
+
+class Module:
+    def register_actions(self):
+        raise NotImplementedError()
+    def unregister_actions(self):
+        raise NotImplementedError()
+
+    #Implement me please and make FilesystemModule loadable

contextshell/backends/Module.py

@@ -1,30 +1,51 @@
 import unittest
+import os
+import tempfile
+from contextshell.TreeRoot import TreeRoot
 from contextshell.VirtualTree import VirtualTree
 from contextshell.NodeTreeRoot import NodeTreeRoot
 from contextshell.NodePath import NodePath
-from tests.functional.ShellTestsBase import VirtualTreeTestsBase
+from tests.functional.ShellTestsBase import TreeRootTestsBase
 from tests.functional.TestExecutor import script_test
+from contextshell.backends.Filesystem import FilesystemRoot
+from contextshell.NodePath import NodePath as np
 
 
-class FilesystemTestsBase(VirtualTreeTestsBase):
-    def configure_virtual_tree(self, virtual_tree: VirtualTree):
-        # TODO: Create FilesystemTreeNode
-        pass
+class FilesystemTestsBase(TreeRootTestsBase):
+    test_directory_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'test_data')
+
+    def create_tree_root(self) -> TreeRoot:
+        self.test_directory = tempfile.TemporaryDirectory(FilesystemTestsBase.__name__)
+        # return FilesystemRoot(self.test_directory.name) # FIXME: make this work
+        return None
 
-    def configure_node_tree(self, tree: NodeTreeRoot):
-        def attach_filesystem(target: NodePath, mount_point: NodePath):
-            tree.create(NodePath(mount_point))
+    def setUp(self):
+        super().setUp()
+        # TODO: create test directory
 
-        def detach(target: NodePath):
-            tree.remove(target)
+    def tearDown(self):
+        # TODO: remove test directory
+        super().tearDown()
 
-        from contextshell.CallableAction import action_from_function
-        tree.install_global_action(action_from_function(attach_filesystem))
-        tree.install_global_action(action_from_function(detach))
 
+class FilesystemRootTests(FilesystemTestsBase):
+    def setUp(self):
+        super().setUp()
+        # TODO: populate test directory
+
+    @script_test
+    def test_contains_existing_file(self):
+        """
+        $ .: contains test_file
+        True
+        """
+
+
+@unittest.skip("Those tests utilize attach actions which may not belong to the filesystem module")
+class AttachTests(TreeRootTestsBase):
+    def create_tree_root(self) -> TreeRoot:
+        pass
 
-@unittest.skip("Re-enable when filesystem module can be installed")
-class AttachTests(VirtualTreeTestsBase):
     def configure_virtual_tree(self, virtual_tree: VirtualTree):
         # TODO: install filesystem module/actions fot attaching
         # Note: VirtualTreeRoot *CAN* append data to the invoked commands

contextshell/backends/__init__.py

@@ -1,21 +1,46 @@
 import unittest
 from abc import ABC, abstractmethod
+
+from contextshell.TreeRoot import TreeRoot
 from contextshell.Shell import Shell
 from contextshell.NodePath import NodePath
 from contextshell.CommandInterpreter import CommandInterpreter
 from contextshell.VirtualTree import VirtualTree
 from contextshell.NodeTreeRoot import NodeTreeRoot
 
 
-class VirtualTreeTestsBase(unittest.TestCase, ABC):
+class ShellScriptTestsBase(unittest.TestCase, ABC):
+    @abstractmethod
+    def create_shell(self) -> Shell:
+        raise NotImplementedError()
+
+
+class TreeRootTestsBase(ShellScriptTestsBase):
+    @abstractmethod
+    def create_tree_root(self) -> TreeRoot:
+        raise NotImplementedError()
+
     def create_shell(self):
-        self.virtual_tree = VirtualTree()
-        self.configure_virtual_tree(self.virtual_tree)
+        self.tree_root = self.create_tree_root()
+        self.configure_tree_root(self.tree_root)
 
-        interpreter = CommandInterpreter(self.virtual_tree)
+        interpreter = CommandInterpreter(self.tree_root)
         shell = Shell(interpreter)
         return shell
 
+    def configure_tree_root(self, tree_root: TreeRoot):
+        pass
+
+
+# TODO: is this class needed when testing single TreeRoot-based class?
+class VirtualTreeTestsBase(TreeRootTestsBase):
+    def create_tree_root(self) -> TreeRoot:
+        return VirtualTree()
+
+    def configure_tree_root(self, tree_root: TreeRoot):
+        self.configure_virtual_tree(tree_root)
+
+
     @abstractmethod
     def configure_virtual_tree(self, virtual_tree: VirtualTree):
         raise NotImplementedError()