[fix] lock del idle

test/test_sandbox_lock.py

@@ -0,0 +1,93 @@
+import threading
+from uuid import UUID
+
+from repository.sandbox_lock import ProcessLocalSandboxLifecycleLocker
+
+CHAT_ID = UUID('77777777-7777-7777-7777-777777777777')
+
+
+class LockRace:
+    def __init__(self, locker: ProcessLocalSandboxLifecycleLocker) -> None:
+        self.locker = locker
+        self.entered_first = threading.Event()
+        self.second_requested = threading.Event()
+        self.second_entered = threading.Event()
+        self.release_first = threading.Event()
+        self.release_second = threading.Event()
+        self.errors: list[Exception] = []
+        self.order: list[str] = []
+        self.first_entry: object | None = None
+
+    def run_first(self) -> None:
+        try:
+            with self.locker.lock(CHAT_ID):
+                self.first_entry = self.locker._locks_by_chat_id[CHAT_ID]
+                self.order.append('first_entered')
+                self.entered_first.set()
+                assert self.release_first.wait(timeout=1)
+                self.order.append('first_releasing')
+        except Exception as exc:
+            self.errors.append(exc)
+
+    def run_second(self) -> None:
+        try:
+            assert self.entered_first.wait(timeout=1)
+            context = self.locker.lock(CHAT_ID)
+            self.second_requested.set()
+
+            with context:
+                self.order.append('second_entered')
+                self.second_entered.set()
+                assert self.release_second.wait(timeout=1)
+                self.order.append('second_releasing')
+        except Exception as exc:
+            self.errors.append(exc)
+
+
+def test_process_local_sandbox_lifecycle_locker_evicts_idle_lock() -> None:
+    locker = ProcessLocalSandboxLifecycleLocker()
+
+    with locker.lock(CHAT_ID):
+        assert CHAT_ID in locker._locks_by_chat_id
+        assert len(locker._locks_by_chat_id) == 1
+
+    assert CHAT_ID not in locker._locks_by_chat_id
+    assert len(locker._locks_by_chat_id) == 0
+
+
+def test_process_local_sandbox_lifecycle_locker_keeps_shared_lock_for_waiters() -> None:
+    locker = ProcessLocalSandboxLifecycleLocker()
+    race = LockRace(locker)
+    first_thread = threading.Thread(target=race.run_first)
+    second_thread = threading.Thread(target=race.run_second)
+
+    first_thread.start()
+    assert race.entered_first.wait(timeout=1)
+
+    second_thread.start()
+    assert race.second_requested.wait(timeout=1)
+    assert len(locker._locks_by_chat_id) == 1
+    assert locker._locks_by_chat_id[CHAT_ID] is race.first_entry
+    assert not race.second_entered.wait(timeout=0.1)
+
+    race.release_first.set()
+    assert race.second_entered.wait(timeout=1)
+    assert len(locker._locks_by_chat_id) == 1
+    assert locker._locks_by_chat_id[CHAT_ID] is race.first_entry
+
+    race.release_second.set()
+
+    first_thread.join(timeout=1)
+    second_thread.join(timeout=1)
+
+    assert not first_thread.is_alive()
+    assert not second_thread.is_alive()
+    assert race.errors == []
+    assert race.order == [
+        'first_entered',
+        'first_releasing',
+        'second_entered',
+        'second_releasing',
+    ]
+    assert CHAT_ID not in locker._locks_by_chat_id
+    assert len(locker._locks_by_chat_id) == 0