'contains' action tests of common backend test suite

Author: idle-code

contextshell/backends/node.py

@@ -92,40 +92,40 @@ 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
+    def remove_action(self, target: NodePath):
         # CHECK: use 'path' argument?
         return self.remove(target)
 
-    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):

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/FilesystemTreeTests.py

@@ -1,8 +1,56 @@
+import os
+import tempfile
 import unittest
+from pathlib import Path
+from typing import List
 
-from contextshell.path import NodePath as np
+from contextshell.action import Executor
+
+from .bases import Base
+
+from contextshell.path import NodePath, NodePath as np  # isort:skip
 
 
 def create_filesystem_tree(*args, **kwargs):
     from contextshell.backends.filesystem import FilesystemTree
     return FilesystemTree(*args, **kwargs)
+
+
+class TemporaryDirectoryTestsBase(unittest.TestCase):
+    """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=''):
+        with open(self._make_test_path(path), 'w') as file:
+            file.write(contents)
+
+    def create_directory(self, path):
+        os.mkdir(self._make_test_path(path))
+
+    def setUp(self):
+        super().setUp()
+        temp_dir_suffix = type(self).__name__
+        self.test_directory = tempfile.TemporaryDirectory(temp_dir_suffix)
+
+    def tearDown(self):
+        self.test_directory.cleanup()
+        super().tearDown()
+
+
+class L0ActionsTests(TemporaryDirectoryTestsBase, Base.L0ActionsTests):
+    def setUp(self):
+        super().setUp()
+        self.create_file('file')
+        self.create_directory('directory')
+
+    def create_backend(self) -> Executor:
+        return create_filesystem_tree(self.test_directory.name)
+
+    @property
+    def existing_paths(self) -> List[NodePath]:
+        return [np('file'), np('directory')]
+
+    @property
+    def nonexistent_paths(self) -> List[NodePath]:
+        return [np('nonexistent')]

tests/unit/backends/NodeTreeTests.py

@@ -1,7 +1,12 @@
 import unittest
+from typing import List
 
-from contextshell.path import NodePath as np
-from tests.unit.Fakes import FakeAction
+from contextshell.action import Executor
+
+from ..fakes import FakeAction
+from .bases import Base
+
+from contextshell.path import NodePath, NodePath as np  # isort:skip
 
 
 def create_tree(*args, **kwargs):
@@ -61,7 +66,7 @@ def test_resolve_optional_existing(self):
 
         resolved_node = tree._resolve_optional_path(existing_path)
 
-        self.assertIs('BAR', resolved_node.get())
+        self.assertEqual('BAR', resolved_node.get())
 
     def test_resolve_optional_nonexistent(self):
         tree = create_tree()
@@ -260,7 +265,7 @@ def test_node_specific_actions(self):
 
 
 class FindFirstInTests(unittest.TestCase):
-    def test_no_canditates_provided(self):
+    def test_no_candidates_provided(self):
         tree = create_tree()
 
         with self.assertRaises(ValueError):
@@ -392,3 +397,21 @@ def test_resolve_order_target_before_global(self):
         found_type = tree.find_type(np('.target'), type_name)
 
         self.assertIs(target_type, found_type)
+
+
+class L0ActionsTests(Base.L0ActionsTests):
+    def setUp(self):
+        super().setUp()
+        self.root = create_tree()
+        self.root.create(np('.node'))
+
+    def create_backend(self) -> Executor:
+        return self.root
+
+    @property
+    def existing_paths(self) -> List[NodePath]:
+        return [np('node')]
+
+    @property
+    def nonexistent_paths(self) -> List[NodePath]:
+        return [np('nonexistent')]

tests/unit/backends/VirtualTreeTests.py

@@ -2,7 +2,7 @@
 
 from contextshell.action import pack_argument_tree
 from contextshell.path import NodePath as np
-from tests.unit.Fakes import FakeActionExecutor
+from tests.unit.fakes import FakeActionExecutor
 
 
 def create_virtual_tree():

tests/unit/backends/bases.py

@@ -0,0 +1,48 @@
+import unittest
+from abc import ABC, abstractmethod
+from typing import List
+
+from contextshell.action import Executor, pack_argument_tree
+
+from contextshell.path import NodePath, NodePath as np  # isort:skip
+
+
+class Base:
+    class ContainsActionTests(ABC, unittest.TestCase):
+        @abstractmethod
+        def create_backend(self) -> Executor:
+            raise NotImplementedError()
+
+        @property
+        @abstractmethod
+        def existing_paths(self) -> List[NodePath]:
+            raise NotImplementedError()
+
+        @property
+        @abstractmethod
+        def nonexistent_paths(self) -> List[NodePath]:
+            raise NotImplementedError()
+
+        def test_existing_paths(self):
+            backend = self.create_backend()
+
+            for path in self.existing_paths:
+                with self.subTest("Existing path", path=path):
+                    args = pack_argument_tree(path)
+                    exists = backend.execute(np("."), np('contains'), args)
+                    self.assertTrue(exists, f"{path} doesn't exist (but should)")
+
+        def test_nonexistent_paths(self):
+            backend = self.create_backend()
+
+            for path in self.nonexistent_paths:
+                with self.subTest("Nonexistent path", path=path):
+                    args = pack_argument_tree(path)
+                    exists = backend.execute(np("."), np('contains'), args)
+                    self.assertFalse(exists, f"{path} exist (but shouldn't)")
+
+    class L0ActionsTests(
+        ContainsActionTests,
+        ABC
+    ):
+        pass