Merge branch 'feature/action-tests' into devel

Author: idle-code

contextshell/backends/filesystem.py

@@ -45,6 +45,10 @@ def list_action(self, target: NodePath) -> List[NodePath]:
             return []
         return list(sorted([NodePath(f.name) for f in dir_path.iterdir()]))
 
-    def list_actions_action(self, _: NodePath) -> List[NodePath]:
+    def list_actions_action(self, _: NodePath, prefix_: NodePath = None) -> List[NodePath]:
         # TODO: list actions depending on target type (might require issue #14)
-        return list(map(lambda a: a.name, self.list_builtin_actions()))
+        prefix = NodePath(prefix_)
+        all_actions = self.list_builtin_actions()
+        action_names = map(lambda a: NodePath(a.name[: len(prefix) + 1]), all_actions)
+        names_matching_prefix = filter(prefix.is_parent_of, action_names)
+        return list(names_matching_prefix)

contextshell/backends/node.py

@@ -92,40 +92,44 @@ def __init__(self):
         self.root = Node(None)
         self.install_default_actions()
 
-    def create_action(self, target: NodePath, path: str, value=None):  # NOCOVER
+    def create_action(self, target: NodePath, path: str, value=None):
         self.create(NodePath.join(target, path), value)
 
-    def contains_action(self, target: NodePath, path: str) -> bool:  # NOCOVER
+    def contains_action(self, target: NodePath, path: str) -> bool:
         return self.contains(NodePath.join(target, path))
 
-    def get_action(self, target: NodePath):  # NOCOVER
+    def get_action(self, target: NodePath):
         return self.get(target)
 
-    def set_action(self, target: NodePath, new_value):  # NOCOVER
+    def set_action(self, target: NodePath, new_value):
         return self.set(target, new_value)
 
-    def list_action(self, target: NodePath):  # NOCOVER
+    def list_action(self, target: NodePath):
         all_list = self.list(target)
         return list(filter(lambda p: not NodePath(p).is_attribute, all_list))
 
-    def list_all_action(self, target: NodePath):  # NOCOVER
+    def list_all_action(self, target: NodePath):
         return self.list(target)
 
-    def list_attributes_action(self, target: NodePath):  # NOCOVER
+    def list_attributes_action(self, target: NodePath):
         all_list = self.list(target)
         return list(filter(lambda p: NodePath(p).is_attribute, all_list))
 
-    def list_actions_action(self, target: NodePath):  # NOCOVER
+    def list_actions_action(self, target: NodePath):
         # FIXME: use the same mechanism as in self.find_action
         # CHECK: consider using find.all.actions action
         actions_branch = NodePath.join(target, "@actions")
         return self.list(actions_branch)
 
-    def remove_action(self, target: NodePath):  # NOCOVER
-        # CHECK: use 'path' argument?
-        return self.remove(target)
+    def remove_action(self, target: NodePath, path: NodePath = None):
+        if path is None:
+            return self.remove(target)
+        path_to_remove = NodePath.join(target, path)
+        if not self.contains(path_to_remove):
+            return None
+        return self.remove(path_to_remove)
 
-    def find_type_action(self, target: NodePath, type_name: str):  # NOCOVER
+    def find_type_action(self, target: NodePath, type_name: str):
         return self.find_type(target, NodePath(type_name))
 
     def install_default_actions(self):

functional_tests.sh

@@ -8,8 +8,9 @@ coverage run \
 	-m unittest \
 		discover \
 		--pattern '*Tests.py' \
-		--start-directory ./ \
-		./tests/functional
+		--top-level-directory ./ \
+		--start-directory ./tests/functional/ \
+		./tests/functional/
 TESTS_PASSED=$?
 
 if [[ $TESTS_PASSED -eq 0 ]];

tests/unit/ActionExecutorTests.py

@@ -3,7 +3,7 @@
 from typing import Optional
 
 from contextshell.action import Action, ActionExecutor, pack_argument_tree
-from tests.unit.Fakes import FakeAction
+from tests.unit.fakes import FakeAction
 
 from contextshell.path import NodePath, NodePath as np  # isort:skip
 

tests/unit/BuiltinExecutorTests.py

@@ -2,7 +2,7 @@
 
 from contextshell.action import BuiltinExecutor
 from contextshell.path import NodePath
-from tests.unit.Fakes import FakeAction
+from tests.unit.fakes import FakeAction
 
 
 class RegisterAction(unittest.TestCase):

tests/unit/backends/FilesystemTreeActionsTests.py

@@ -0,0 +1,183 @@
+import tempfile
+import unittest
+from pathlib import Path
+
+from .bases import ActionTestsBase
+
+
+def create_filesystem_tree(*args, **kwargs):
+    from contextshell.backends.filesystem import FilesystemTree
+    return FilesystemTree(*args, **kwargs)
+
+
+class FilesystemActionsTestsBase(ActionTestsBase):
+    """Test base for tests wishing to use actual filesystem directory"""
+    def _make_test_path(self, relative_path):
+        return Path(self.test_directory.name).joinpath(relative_path)
+
+    def create_file(self, path: str, contents: str=None):
+        full_path = self._make_test_path(path)
+        full_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(full_path, 'w') as file:
+            file.write(contents if contents else '')
+
+    def create_directory(self, path):
+        full_path = self._make_test_path(path)
+        full_path.mkdir(parents=True)
+
+    def create_backend(self):
+        return create_filesystem_tree(self.test_directory.name)
+
+    def setUp(self):
+        temp_dir_suffix = type(self).__name__
+        self.test_directory = tempfile.TemporaryDirectory(temp_dir_suffix)
+
+        super().setUp()
+
+    def tearDown(self):
+        self.test_directory.cleanup()
+        super().tearDown()
+
+
+class ContainsActionTests(FilesystemActionsTestsBase):
+    def test_existing_file(self):
+        self.create_file('file')
+
+        exists = self.execute(".", "contains", 'file')
+
+        self.assertTrue(exists)
+
+    def test_existing_file_nested(self):
+        self.create_file('parent/file')
+
+        exists = self.execute(".", "contains", 'parent.file')
+
+        self.assertTrue(exists)
+
+    def test_existing_directory(self):
+        self.create_directory('dir')
+
+        exists = self.execute(".", "contains", 'dir')
+
+        self.assertTrue(exists)
+
+    def test_nonexistent(self):
+        exists = self.execute(".", "contains", 'nonexistent')
+
+        self.assertFalse(exists)
+
+    def test_nonexistent_nested(self):
+        self.create_directory('parent')
+
+        exists = self.execute(".", "contains", 'parent.path')
+
+        self.assertFalse(exists)
+
+
+class GetActionTests(FilesystemActionsTestsBase):
+    def test_empty_file(self):
+        self.create_file('file')
+
+        file_value = self.execute(".file", "get")
+
+        self.assertEqual(file_value, '')
+
+    def test_file(self):
+        self.create_file('file', 'DATA')
+
+        file_value = self.execute(".file", "get")
+
+        self.assertEqual(file_value, 'DATA')
+
+    def test_directory(self):
+        self.create_directory('dir')
+
+        dir_value = self.execute(".dir", "get")
+
+        self.assertEqual(dir_value, None)
+
+
+class IsActionTests(FilesystemActionsTestsBase):
+    def test_directory_is_file(self):
+        self.create_directory('dir')
+
+        is_file = self.execute(".dir", "is.file")
+
+        self.assertFalse(is_file)
+
+    def test_file_is_file(self):
+        self.create_file('file')
+
+        is_file = self.execute(".file", "is.file")
+
+        self.assertTrue(is_file)
+
+    def test_directory_is_directory(self):
+        self.create_directory('dir')
+
+        is_dir = self.execute(".dir", "is.directory")
+
+        self.assertTrue(is_dir)
+
+    def test_file_is_directory(self):
+        self.create_file('file')
+
+        is_dir = self.execute(".file", "is.directory")
+
+        self.assertFalse(is_dir)
+
+
+class ListActionTests(FilesystemActionsTestsBase):
+    def test_list_file(self):
+        self.create_file('file')
+
+        file_list = self.execute(".file", "list")
+
+        self.assertEqual(file_list, [])
+
+    def test_list_empty_directory(self):
+        self.create_directory('dir')
+
+        file_list = self.execute(".dir", "list")
+
+        self.assertEqual(file_list, [])
+
+    def test_list_directory_with_file_and_dirs(self):
+        self.create_directory('parent/dir')
+        self.create_file('parent/file')
+
+        file_list = self.execute(".parent", "list")
+
+        self.assertIn('dir', file_list)
+        self.assertIn('file', file_list)
+
+    @unittest.skip("Re-enable when path uses '/' as separator")
+    def test_list_hidden(self):
+        self.create_directory('parent/.dir')
+        self.create_file('parent/.file')
+
+        file_list = self.execute(".parent", "list")
+
+        self.assertListEqual(file_list, [])
+
+    @unittest.skip("Re-enable when path uses '/' as separator")
+    def test_list_all(self):
+        self.create_directory('parent/.dir')
+        self.create_file('parent/.file')
+
+        file_list = self.execute(".parent", "list.all")
+
+        self.assertIn('@dir', file_list)
+        self.assertIn('@file', file_list)
+
+
+class ListActionsActionTests(FilesystemActionsTestsBase):
+    def test_list_all(self):
+        action_list = self.execute(".", "list.actions")
+
+        self.assertSetEqual({'contains', 'get', 'is', 'list'}, set(action_list))
+
+    def test_list_nested(self):
+        action_list = self.execute(".", "list.actions", "is")
+
+        self.assertSetEqual({'is.file', 'is.directory'}, set(action_list))