Make scan directory manager thread safe

tests/test_lock_decorator.py

@@ -0,0 +1,124 @@
+"""Tests for the ``requires_lock`` decorator in ``utilities.py``."""
+
+import threading
+from time import sleep, time
+
+import pytest
+
+from openflexure_microscope_server.utilities import requires_lock
+
+
+class LockableClass:
+    """A class with methods that can be locked with the ``requires_lock`` decorator."""
+
+    def __init__(self):
+        """Initialise the LockableClass with a rentrant lock."""
+        self._lock = threading.RLock()
+
+    @property
+    @requires_lock
+    def test_property(self) -> int:
+        """A property that always returns 1."""
+        return 1
+
+    @requires_lock
+    def fast_task(self) -> int:
+        """Instantly return the number 2."""
+        return 2
+
+    @requires_lock
+    def slow_task(self) -> int:
+        """Take 0.5s to return the number 3."""
+        sleep(0.5)
+        return 3
+
+    @requires_lock
+    def task_that_calls_fast_task(self) -> int:
+        """Require a lock and call a fast task that requires it too."""
+        return self.fast_task()
+
+    @requires_lock
+    def task_that_calls_property(self) -> int:
+        """Require a lock and call a property that requires it too."""
+        return self.test_property
+
+
+@pytest.fixture
+def lockable_obj() -> LockableClass:
+    """Return an instance of LockableClass."""
+    return LockableClass()
+
+
+def test_error_if_no_lock(lockable_obj):
+    """Test there is an Attribute error if the object has no lock attribute."""
+    # Delete the lock!
+    del lockable_obj._lock
+    with pytest.raises(AttributeError) as exec_info:
+        lockable_obj.test_property
+    assert str(exec_info.value) == "LockableClass has no '_lock' attribute"
+
+
+def test_functionality(lockable_obj):
+    """Check that this doesn't affect the most basic functionality of the class."""
+    assert lockable_obj.test_property == 1
+    assert lockable_obj.fast_task() == 2
+    # Don't check slow task here as it is slow and functionally no different from fast
+    # task.
+    # Check tasks that call other tasks locked to check that they are rentrant
+    assert lockable_obj.task_that_calls_property() == 1
+    assert lockable_obj.task_that_calls_fast_task() == 2
+
+
+def check_fast_target_waits(lockable_obj, fast_target):
+    """Start threads with a slow target and the supplied fast target, check lock works.
+
+    :param lockable_obj: An instance of LockableClass
+    :param fast_target: The callable to test with the fast thread.
+
+    The program runs by:
+
+    * First checking that fast_target when run on its own completes in less than
+        0.1s
+    * Starts the thread with the slow_target.
+    * Starts the thread with the fast_target straight afterwards.
+    * Wait for the fast target to complete.
+    * Check the slow target has completeted once returned (showing that the fast
+        target had to wait because of the lock)
+    * Check that the time elapsed is over 0.4s.
+    """
+    # On its own the fast thread is fast.
+    fast_thread = threading.Thread(target=fast_target)
+    t_start = time()
+    fast_thread.start()
+    fast_thread.join()
+    assert time() - t_start < 0.1
+
+    # If slow thread is running it has to wait.
+    fast_thread = threading.Thread(target=fast_target)
+    slow_thread = threading.Thread(target=lockable_obj.slow_task)
+
+    t_start = time()
+    slow_thread.start()
+    fast_thread.start()
+    fast_thread.join()
+    # slow task must have finished
+    assert not slow_thread.is_alive()
+    assert time() - t_start > 0.4
+
+
+def test_locking(lockable_obj):
+    """Test the locking works when calling decorated methods in two threads."""
+    check_fast_target_waits(lockable_obj, lockable_obj.fast_task)
+
+
+def test_property_locking(lockable_obj):
+    """Test that the locking works when calling a property not a function.
+
+    The target is a method with no lock, that calls the property that requires
+    the lock.
+    """
+
+    def property_caller() -> int:
+        return lockable_obj.test_property
+
+    check_fast_target_waits(lockable_obj, property_caller)