redis-allocator 0.0.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

tests/test_allocator.py

@@ -6,520 +6,493 @@ This module tests the functionality of:
 2. RedisAllocator - For distributed resource allocation
 3. RedisAllocatorObject - For managing allocated resources
 """
-import pytest
-from unittest.mock import MagicMock, patch, call
-from redis import RedisError
-from redis_allocator.allocator import RedisAllocator, RedisThreadHealthCheckPool, RedisAllocatorObject, RedisAllocatableClass, RedisLockPool
-
-
-# Use the _TestObject naming to avoid pytest trying to collect it as a test class
-class _TestObject(RedisAllocatableClass):
-    """Test implementation of RedisAllocatableClass for testing."""
-    
-    def __init__(self):
-        self.config_key = None
-        self.config_params = None
-        self.closed = False
-    
-    def set_config(self, key, params):
-        """Set configuration parameters."""
-        self.config_key = key
-        self.config_params = params
-    
-    def close(self):
-        """Mark the object as closed."""
-        self.closed = True
-    
-    def name(self):
-        """Return a name for soft binding."""
-        return "test_object"
-
-
-@pytest.fixture
-def test_object():
-    """Create a test object implementing RedisAllocatableClass."""
-    return _TestObject()
-
-
-@pytest.fixture
-def allocator(redis_client):
-    """Create a RedisAllocator instance for testing."""
-    alloc = RedisAllocator(
-        redis_client, 
-        'test', 
-        'alloc-lock',
-        shared=False
-    )
-    # Set up initial keys
-    alloc.extend(['key1', 'key2', 'key3'])
-    return alloc
-
-
-@pytest.fixture
-def shared_allocator(redis_client):
-    """Create a shared RedisAllocator instance for testing."""
-    alloc = RedisAllocator(
-        redis_client, 
-        'test', 
-        'shared-alloc',
-        shared=True
-    )
-    # Set up initial keys
-    alloc.extend(['key1', 'key2', 'key3'])
-    return alloc
-
-
-@pytest.fixture
-def health_checker(redis_client):
-    """Create a RedisThreadHealthCheckPool instance for testing."""
-    return RedisThreadHealthCheckPool(
-        redis_client,
-        'test',
-        timeout=60
-    )
-
+import time
+import datetime
+import threading
+from operator import xor
+from pytest_mock import MockFixture
+from redis import Redis
+from freezegun import freeze_time
+from redis_allocator.allocator import (
+    RedisAllocator, RedisThreadHealthCheckPool, RedisAllocatorObject,
+)
+from tests.conftest import _TestObject
 
 class TestRedisThreadHealthCheckPool:
     """Tests for the RedisThreadHealthCheckPool class."""
 
-    def test_initialization(self, health_checker, redis_client):
-        """Test that initialization correctly registers the thread and sets up monitoring."""
-        # Initialization should register the current thread
-        assert health_checker.current_thread_id is not None
-        # Initialization calls update and extend, no need to check Redis calls directly
-        # since we're testing the object's behavior, not implementation details
-        assert hasattr(health_checker, 'timeout')
-
-    def test_update(self, health_checker, redis_client):
-        """Test that update refreshes the thread's health status."""
-        # Override the parent class's update method to verify our object behavior
-        with patch.object(RedisLockPool, 'update') as mock_update:
-            # Call update
-            health_checker.update()
-            
-            # Should call the parent's update method with thread ID and timeout
-            mock_update.assert_called_once_with(health_checker.current_thread_id, timeout=health_checker.timeout)
-
-    def test_finalize(self, health_checker, redis_client):
-        """Test that finalize cleans up thread resources."""
-        # Override the parent class's methods to verify our object behavior
-        with patch.object(RedisLockPool, 'shrink') as mock_shrink:
-            with patch.object(RedisLockPool, 'unlock') as mock_unlock:
-                # Call finalize
-                health_checker.finalize()
-                
-                # Should call shrink with thread ID
-                mock_shrink.assert_called_once_with([health_checker.current_thread_id])
-                # Should call unlock with thread ID
-                mock_unlock.assert_called_once_with(health_checker.current_thread_id)
-
-    def test_custom_timeout(self, redis_client):
-        """Test initialization with a custom timeout value."""
-        custom_timeout = 120
-        checker = RedisThreadHealthCheckPool(redis_client, 'test', timeout=custom_timeout)
-        assert checker.timeout == custom_timeout
-
-    def test_multiple_initialize_calls(self, health_checker):
-        """Test calling initialize multiple times."""
-        with patch.object(RedisLockPool, 'update') as mock_update:
-            with patch.object(RedisLockPool, 'extend') as mock_extend:
-                # Call initialize again
-                health_checker.initialize()
-                health_checker.initialize()
-                
-                # Should have called update and extend each time
-                assert mock_update.call_count == 2
-                assert mock_extend.call_count == 2
+    def test_thread_health_check(self, redis_client: Redis):
+        """Test the thread health check mechanism in a multi-thread environment.
+
+        This test creates actual threads:
+        - Some threads are "healthy" (regularly update their status)
+        - Some threads are "unhealthy" (stop updating their status)
+
+        We verify that the health check correctly identifies the healthy vs unhealthy threads.
+        """
+
+        # Set up a health checker with a short timeout to make testing faster
+        health_timeout = 60  # 3 seconds timeout for faster testing
+
+        # Start time for our simulation
+        start_time = datetime.datetime(2023, 1, 1, 12, 0, 0)
+
+        with freeze_time(start_time) as frozen_time:
+            checker = RedisThreadHealthCheckPool(redis_client, 'test-health', timeout=health_timeout)
+
+            # Track thread IDs for verification
+            thread_ids = {}
+            threads = []
+            stop_event = threading.Event()
+
+            # Thread that keeps updating (healthy)
+            def healthy_thread():
+                checker.initialize()
+                thread_id = str(threading.current_thread().ident)
+                thread_ids[threading.current_thread().name] = thread_id
+                while not stop_event.is_set():
+                    checker.update()
+                    # We don't actually sleep in the threads
+                    # They'll continue running while we control time externally
+                    if stop_event.wait(0.01):  # Small wait to prevent CPU spinning
+                        break
+
+            # Thread that stops updating (becomes unhealthy)
+            def unhealthy_thread():
+                checker.initialize()
+                thread_id = str(threading.current_thread().ident)
+                thread_ids[threading.current_thread().name] = thread_id
+                # Only update once, then stop (simulating a dead thread)
+
+            # Create and start threads
+            for i in range(3):
+                t = threading.Thread(target=healthy_thread, name=f"healthy-{i}", daemon=True)
+                t.start()
+                threads.append(t)
+
+            for i in range(2):
+                t = threading.Thread(target=unhealthy_thread, name=f"unhealthy-{i}", daemon=True)
+                t.start()
+                threads.append(t)
+
+            # Wait for all threads to register
+            # Instead of time.sleep(1), advance time using freeze_time
+            frozen_time.tick(1.0)
+
+            # Get initial thread status - all should be healthy initially
+            registered_threads = list(checker.keys())
+            for thread_name, thread_id in thread_ids.items():
+                assert thread_id in registered_threads, f"Thread {thread_name} should be registered"
+                assert checker.is_locked(thread_id), f"Thread {thread_id} should be locked/healthy"
+
+            # Wait for unhealthy threads to expire
+            # Advance time past the health_timeout
+            frozen_time.tick(health_timeout + 1)
+            time.sleep(0.1)
+            # Now verify healthy vs unhealthy status
+            for thread_name, thread_id in thread_ids.items():
+                if thread_name.startswith("healthy"):
+                    assert checker.is_locked(thread_id), f"Thread {thread_name} should still be locked/healthy"
+                else:
+                    assert not checker.is_locked(thread_id), f"Thread {thread_name} should be unlocked/unhealthy"
+
+            # Clean up
+            stop_event.set()
+
+    def test_thread_recovery(self, redis_client: Redis):
+        """Test that a thread can recover after being marked as unhealthy.
+
+        This simulates a scenario where a thread stops updating for a while (becomes unhealthy),
+        but then recovers and starts updating again (becomes healthy).
+        """
+
+        # Start time for our simulation
+        start_time = datetime.datetime(2023, 1, 1, 12, 0, 0)
+
+        with freeze_time(start_time) as frozen_time:
+            # Set up a health checker with a short timeout
+            health_timeout = 2  # 2 seconds timeout for faster testing
+            checker = RedisThreadHealthCheckPool(redis_client, 'test-recovery', timeout=health_timeout)
+
+            # Control variables
+            pause_updates = threading.Event()
+            resume_updates = threading.Event()
+            stop_thread = threading.Event()
+            thread_id = None
+
+            # Thread function that will pause and resume updates
+            def recovery_thread():
+                nonlocal thread_id
+                checker.initialize()
+                thread_id = str(threading.current_thread().ident)
+
+                # Update until told to pause
+                while not pause_updates.is_set() and not stop_thread.is_set():
+                    checker.update()
+                    stop_thread.wait(0.01)  # Small wait to prevent CPU spinning
+
+                # Wait until told to resume
+                resume_updates.wait()
+
+                if not stop_thread.is_set():
+                    # Recover by re-initializing
+                    checker.initialize()
+
+                    # Continue updating
+                    while not stop_thread.is_set():
+                        checker.update()
+                        stop_thread.wait(0.01)
+
+            # Start the thread
+            thread = threading.Thread(target=recovery_thread)
+            thread.daemon = True
+            thread.start()
+
+            # Wait for thread to initialize
+            frozen_time.tick(0.5)
+
+            # Verify thread is initially healthy
+            assert thread_id is not None, "Thread ID should be set"
+            assert checker.is_locked(thread_id), "Thread should be healthy after initialization"
+
+            # Pause updates to let the thread become unhealthy
+            pause_updates.set()
+
+            # Wait for thread to become unhealthy by advancing time
+            frozen_time.tick(health_timeout + 1)
+
+            # Verify thread is now unhealthy
+            assert not checker.is_locked(thread_id), "Thread should be unhealthy after timeout"
+
+            # Tell thread to resume updates
+            resume_updates.set()
+
+            # Wait for thread to recover
+            frozen_time.tick(1.0)
+            time.sleep(0.1)
+
+            # Verify thread is healthy again
+            assert checker.is_locked(thread_id), "Thread should be healthy after recovery"
+
+            # Clean up
+            stop_thread.set()
+            thread.join(timeout=1)
 
 
 class TestRedisAllocatorObject:
     """Tests for the RedisAllocatorObject class."""
-    
-    def test_initialization(self, allocator, test_object):
+
+    def test_initialization(self, redis_allocator: RedisAllocator, test_object: _TestObject):
         """Test that initialization correctly sets up the object."""
-        # Create a test params dict
         params = {"param1": "value1", "param2": "value2"}
-        
-        # Create a RedisAllocatorObject
-        obj = RedisAllocatorObject(allocator, "test_key", test_object, params)
-        
-        # Verify properties
-        assert obj._allocator == allocator
+        obj = RedisAllocatorObject(redis_allocator, "test_key", test_object, params)
+
+        assert obj.allocator == redis_allocator
         assert obj.key == "test_key"
         assert obj.obj == test_object
         assert obj.params == params
-        
-        # Verify set_config was called on the wrapped object
         assert test_object.config_key == "test_key"
         assert test_object.config_params == params
-    
-    def test_initialization_with_defaults(self, allocator):
-        """Test initialization with default None values."""
-        # Create a RedisAllocatorObject with default None values
-        obj = RedisAllocatorObject(allocator, "test_key")
-        
-        # Verify properties
-        assert obj._allocator == allocator
-        assert obj.key == "test_key"
-        assert obj.obj is None
-        assert obj.params is None
-    
-    def test_update(self, allocator, test_object):
-        """Test the update method (renamed from lock)."""
-        # Create a RedisAllocatorObject
-        obj = RedisAllocatorObject(allocator, "test_key", test_object, {})
-        
-        # Reset mock
-        allocator.update = MagicMock()
-        
-        # Call update with positive timeout
+
+    def test_update(self, redis_allocator: RedisAllocator, test_object: _TestObject, mocker: MockFixture):
+        """Test the update method."""
+        obj = RedisAllocatorObject(redis_allocator, "test_key", test_object, {})
+        mock_alloc_update = mocker.patch.object(redis_allocator, 'update')
+        mock_alloc_free = mocker.patch.object(redis_allocator, 'free')
         obj.update(60)
-        
-        # Verify update was called
-        allocator.update.assert_called_once_with("test_key", timeout=60)
-    
-    def test_update_with_zero_timeout(self, allocator, test_object):
-        """Test update with zero timeout, which should free the object."""
-        # Create a RedisAllocatorObject
-        obj = RedisAllocatorObject(allocator, "test_key", test_object, {})
-        
-        # Reset mocks
-        allocator.update = MagicMock()
-        allocator.free = MagicMock()
-        
-        # Call update with zero timeout
+        mock_alloc_update.assert_called_once_with("test_key", timeout=60)
+        mock_alloc_free.assert_not_called()
         obj.update(0)
-        
-        # Verify free was called instead of update
-        allocator.update.assert_not_called()
-        allocator.free.assert_called_once_with(obj)
-    
-    def test_close(self, allocator, test_object):
+        mock_alloc_update.assert_called_once()
+        mock_alloc_free.assert_called_once()
+
+    def test_close(self, redis_allocator: RedisAllocator, test_object: _TestObject):
         """Test the close method."""
-        # Create a RedisAllocatorObject
-        obj = RedisAllocatorObject(allocator, "test_key", test_object, {})
-        
-        # Call close
+        obj = RedisAllocatorObject(redis_allocator, "test_key", test_object, {})
+        obj.open()
+        assert not test_object.closed
         obj.close()
-        
-        # Verify close was called on the wrapped object
         assert test_object.closed
-    
-    def test_close_with_none_object(self, allocator):
-        """Test the close method with None object."""
-        # Create a RedisAllocatorObject with None object
-        obj = RedisAllocatorObject(allocator, "test_key")
-        
-        # Call close should not raise any exception
-        obj.close()
-    
-    def test_del(self, allocator, test_object):
+        obj.close()  # Should not raise
+
+    def test_del(self, redis_allocator: RedisAllocator, test_object: _TestObject, mocker: MockFixture):
         """Test the __del__ method."""
-        # Create a RedisAllocatorObject
-        obj = RedisAllocatorObject(allocator, "test_key", test_object, {})
-        
-        # Patch close method to verify it gets called
-        obj.close = MagicMock()
-        
-        # Simulate __del__ being called
+        obj = RedisAllocatorObject(redis_allocator, "test_key", test_object, {})
+        obj.close = mocker.MagicMock()
         obj.__del__()
-        
-        # Verify close was called
         obj.close.assert_called_once()
 
 
 class TestRedisAllocator:
     """Tests for the RedisAllocator class."""
-    
-    def test_initialization(self, redis_client):
-        """Test the initialization of RedisAllocator."""
-        allocator = RedisAllocator(redis_client, 'test', 'alloc-lock')
-        
-        # Should have an empty WeakValueDictionary for objects
-        assert len(allocator.objects) == 0
-        # Should be initialized with default values
-        assert allocator.shared is False
-        # Should have default soft_bind_timeout
-        assert allocator.soft_bind_timeout == 3600
-    
-    def test_initialization_with_custom_values(self, redis_client):
-        """Test initialization with custom values."""
-        eps = 1e-8
-        allocator = RedisAllocator(
-            redis_client, 
-            'custom_prefix', 
-            suffix='custom_suffix',
-            eps=eps,
-            shared=True
+
+    def get_redis_pool_state(self, redis_allocator: RedisAllocator, redis_client: Redis):
+        """Get the current state of the Redis pool."""
+        head_key = redis_client.get(redis_allocator._pool_pointer_str(True))
+        tail_key = redis_client.get(redis_allocator._pool_pointer_str(False))
+        pool_state = redis_client.hgetall(redis_allocator._pool_str())
+        locked_status = dict(redis_allocator.items_locked_status())
+        return {
+            "pool_state": pool_state,
+            "head_key": head_key,
+            "tail_key": tail_key,
+            "locked_status": locked_status
+        }
+
+    def time_to_expire(self, redis_client: Redis, timeout: int):
+        if timeout > 0:
+            return int(redis_client.time()[0]) + timeout
+        return -1
+
+    def generate_pool_state(self, redis_client: Redis, free_keys: list[str | tuple[str, int]], allocated_keys: list[str | tuple[str, int]]):
+        free_keys = [keys if isinstance(keys, tuple) else (keys, -1) for keys in free_keys]
+        allocated_keys = [keys if isinstance(keys, tuple) else (keys, -1) for keys in allocated_keys]
+
+        state = {
+            "pool_state": {},
+            "head_key": free_keys[0][0] if len(free_keys) > 0 else '',
+            "tail_key": free_keys[-1][0] if len(free_keys) > 0 else '',
+            "locked_status": {},
+        }
+        for prev_key, current_key, next_key in zip([('', -1)] + free_keys[:-1], free_keys, free_keys[1:] + [('', -1)]):
+            state["pool_state"][current_key[0]] = f'{prev_key[0]}||{next_key[0]}||{self.time_to_expire(redis_client, current_key[1])}'
+            state["locked_status"][current_key[0]] = False
+        for key in allocated_keys:
+            state["pool_state"][key[0]] = f'#ALLOCATED||#ALLOCATED||{self.time_to_expire(redis_client, key[1])}'
+            state["locked_status"][key[0]] = True
+        return state
+
+    def test_initialization(self, redis_allocator: RedisAllocator, redis_client: Redis):
+        """Test the initialization of Redisredis_allocator."""
+        assert self.get_redis_pool_state(redis_allocator, redis_client) == self.generate_pool_state(
+            redis_client,
+            ['key1', 'key2', 'key3'],
+            []
         )
-        
-        # Should have custom values
-        assert allocator.prefix == 'custom_prefix'
-        assert allocator.suffix == 'custom_suffix'
-        assert allocator.eps == eps
-        assert allocator.shared is True
-    
-    def test_object_key_non_shared(self, allocator, test_object):
-        """Test the object_key method in non-shared mode."""
-        # In non-shared mode, should return the key as is
-        allocator.shared = False
-        result = allocator.object_key("test_key", test_object)
-        assert result == "test_key"
-    
-    def test_object_key_shared(self, allocator, test_object):
-        """Test the object_key method in shared mode."""
-        # In shared mode, should return key:obj
-        allocator.shared = True
-        result = allocator.object_key("test_key", test_object)
-        assert result == f"test_key:{test_object}"
-    
-    def test_object_key_with_none(self, allocator):
-        """Test the object_key method with None object."""
-        # With None object, should still work
-        allocator.shared = True
-        result = allocator.object_key("test_key", None)
-        assert result == "test_key:None"
-        
-        allocator.shared = False
-        result = allocator.object_key("test_key", None)
-        assert result == "test_key"
-    
-    def test_extend(self, allocator, redis_client):
-        """Test the extend method."""
-        # Clear any existing data
-        redis_client.flushall()
-        
-        # Call extend
-        allocator.extend(["key4", "key5"])
-        
-        # Verify keys were added
-        assert "key4" in allocator
-        assert "key5" in allocator
-    
-    def test_extend_empty(self, allocator, redis_client):
-        """Test extend with empty keys."""
-        # Clear any existing data
-        redis_client.flushall()
-        
-        # Call extend with empty list
-        allocator.extend([])
-        allocator.extend(None)
-        
-        # No keys should be added
-        assert len(list(allocator.keys())) == 0
-    
-    def test_shrink(self, allocator, redis_client):
-        """Test the shrink method."""
-        # Clear any existing data
-        redis_client.flushall()
-        
-        # Add some keys first
-        allocator.extend(["key1", "key2", "key3"])
-        
-        # Call shrink
-        allocator.shrink(["key1", "key2"])
-        
-        # Verify keys were removed
-        assert "key1" not in allocator
-        assert "key2" not in allocator
-        assert "key3" in allocator
-    
-    def test_shrink_empty(self, allocator, redis_client):
-        """Test shrink with empty keys."""
-        # Clear any existing data
-        redis_client.flushall()
-        
-        # Add some keys first
-        allocator.extend(["key1", "key2"])
-        
-        # Call shrink with empty list
-        allocator.shrink([])
-        allocator.shrink(None)
-        
-        # Keys should remain unchanged
-        assert "key1" in allocator
-        assert "key2" in allocator
-    
-    def test_assign(self, allocator, redis_client):
-        """Test the assign method."""
-        # Clear any existing data
-        redis_client.flushall()
-        
-        # Add some initial keys
-        allocator.extend(["key1", "key2"])
-        
-        # Call assign with new keys
-        allocator.assign(["key3", "key4"])
-        
-        # Verify old keys are gone and new keys are present
-        assert "key1" not in allocator
-        assert "key2" not in allocator
-        assert "key3" in allocator
-        assert "key4" in allocator
-        
-        # Call assign with None
-        allocator.assign(None)
-        
-        # All keys should be gone
-        assert len(list(allocator.keys())) == 0
-    
-    def test_assign_empty(self, allocator, redis_client):
-        """Test assign with empty keys."""
-        # Clear any existing data
-        redis_client.flushall()
-        
-        # Add some initial keys
-        allocator.extend(["key1", "key2"])
-        
-        # Call assign with empty list
-        allocator.assign([])
-        
-        # All keys should be gone
-        assert len(list(allocator.keys())) == 0
-    
-    def test_clear(self, allocator, redis_client):
-        """Test the clear method."""
-        # Clear any existing data
-        redis_client.flushall()
-        
-        # Add some keys
-        allocator.extend(["key1", "key2"])
-        
-        # Call clear
-        allocator.clear()
-        
-        # All keys should be gone
-        assert len(list(allocator.keys())) == 0
-    
-    def test_redis_error_in_clear(self, allocator, redis_client):
-        """Test handling Redis errors in clear."""
-        # Clear any existing data
-        redis_client.flushall()
-        
-        # Add some keys
-        allocator.extend(["key1", "key2"])
-        
-        # Mock Redis error
-        redis_client.delete = lambda *args: (_ for _ in ()).throw(RedisError("Test error"))
-        
-        # Call clear should raise RedisError
-        with pytest.raises(RedisError):
-            allocator.clear()
-    
-    def test_keys(self, allocator, redis_client):
-        """Test the keys method."""
-        # Clear any existing data
-        redis_client.flushall()
-        
-        # Add some keys
-        allocator.extend(["key1", "key2", "key3"])
-        
-        # Get keys
-        result = list(allocator.keys())
-        
-        # Verify we got all keys
-        assert set(result) == {"key1", "key2", "key3"}
-    
-    def test_redis_error_in_keys(self, allocator, redis_client):
-        """Test handling Redis errors in keys."""
-        # Clear any existing data
-        redis_client.flushall()
-        
-        # Add some keys
-        allocator.extend(["key1", "key2"])
-        
-        # Mock Redis error
-        redis_client.hkeys = lambda *args: (_ for _ in ()).throw(RedisError("Test error"))
-        
-        # Getting keys should raise RedisError
-        with pytest.raises(RedisError):
-            list(allocator.keys())
-    
-    def test_contains(self, allocator, redis_client):
-        """Test the __contains__ method."""
-        # Clear any existing data
-        redis_client.flushall()
-        
-        # Add some keys
-        allocator.extend(["key1", "key2"])
-        
-        # Check containment
-        assert "key1" in allocator
-        assert "key2" in allocator
-        assert "key3" not in allocator
-    
-    def test_redis_error_in_contains(self, allocator, redis_client):
-        """Test handling Redis errors in __contains__."""
-        # Clear any existing data
-        redis_client.flushall()
-        
-        # Add some keys
-        allocator.extend(["key1", "key2"])
-        
-        # Mock Redis error
-        redis_client.hexists = lambda *args: (_ for _ in ()).throw(RedisError("Test error"))
-        
-        # Checking containment should raise RedisError
-        with pytest.raises(RedisError):
-            "key1" in allocator
-    
-    def test_update_soft_bind(self, allocator, redis_client):
-        """Test the update_soft_bind method."""
-        # Set up mock
-        allocator.update = MagicMock()
-        
-        # Call update_soft_bind
-        allocator.update_soft_bind("test_name", "test_key")
-        
-        # Verify update was called with the right parameters
-        allocator.update.assert_called_once_with(
-            allocator._soft_bind_name("test_name"), 
-            "test_key", 
-            timeout=allocator.soft_bind_timeout
+
+    def test_allocation_and_freeing(self, redis_allocator: RedisAllocator, redis_client: Redis):
+        """Test basic allocation/freeing using Lua scripts and verify Redis state."""
+        shared = redis_allocator.shared
+        test_keys = ["key1", "key2", "key3"]
+        redis_allocator.extend(test_keys)
+        self.test_initialization(redis_allocator, redis_client)
+
+        for key in test_keys:
+            assert key in redis_allocator
+            assert not redis_allocator.is_locked(key)
+            assert not redis_client.exists(redis_allocator._key_str(key))
+
+        allocated_key = redis_allocator.malloc_key(timeout=30)
+        assert allocated_key == "key1"
+        assert xor(shared, redis_allocator.is_locked(allocated_key))
+        assert xor(shared, redis_client.exists(redis_allocator._key_str(allocated_key)))
+        assert redis_client.ttl(redis_allocator._key_str(allocated_key)) <= 30
+        assert self.get_redis_pool_state(redis_allocator, redis_client) == self.generate_pool_state(
+            redis_client,
+            (['key2', 'key3', 'key1'] if shared else ['key2', 'key3']),
+            ([] if shared else ['key1'])
+        )
+
+        allocated_key = redis_allocator.malloc_key(timeout=30)
+        assert allocated_key == "key2"
+        assert xor(shared, redis_allocator.is_locked(allocated_key))
+        assert xor(shared, redis_client.exists(redis_allocator._key_str(allocated_key)))
+        assert redis_client.ttl(redis_allocator._key_str(allocated_key)) <= 30
+        assert self.get_redis_pool_state(redis_allocator, redis_client) == self.generate_pool_state(
+            redis_client,
+            (['key3', 'key1', 'key2'] if shared else ['key3']),
+            ([] if shared else ['key1', 'key2'])
+        )
+
+        redis_allocator.free_keys("key1")
+        assert self.get_redis_pool_state(redis_allocator, redis_client) == self.generate_pool_state(
+            redis_client,
+            (['key3', 'key1', 'key2'] if shared else ['key3', 'key1']),
+            ([] if shared else ['key2'])
         )
-    
-    def test_unbind_soft_bind(self, allocator, redis_client):
-        """Test the unbind_soft_bind method."""
-        # Set up mock
-        allocator.unlock = MagicMock()
-        
-        # Call unbind_soft_bind
-        allocator.unbind_soft_bind("test_name")
-        
-        # Verify unlock was called with the right parameter
-        allocator.unlock.assert_called_once_with(allocator._soft_bind_name("test_name"))
-    
-    def test_soft_bind_with_empty_name(self, allocator):
-        """Test soft bind methods with empty name."""
-        # Set up mocks
-        allocator.update = MagicMock()
-        allocator.unlock = MagicMock()
-        
-        # Call methods with empty name
-        allocator.update_soft_bind("", "test_key")
-        allocator.unbind_soft_bind("")
-        
-        # Should still call the underlying methods with empty string
-        allocator.update.assert_called_once()
-        allocator.unlock.assert_called_once()
-        
-        # The soft bind name should be generated even with empty string
-        assert allocator._soft_bind_name("") != ""
-    
-    def test_shared_vs_non_shared_allocation(self, allocator, shared_allocator):
-        """Test difference between shared and non-shared allocation."""
-        # Set up mocks for both allocators
-        allocator._malloc_script = MagicMock(return_value="key1")
-        shared_allocator._malloc_script = MagicMock(return_value="key1")
-        
-        # Check the malloc_lua_script property for both allocators
-        non_shared_script = allocator._malloc_lua_script
-        shared_script = shared_allocator._malloc_lua_script
-        
-        # The scripts should be different, with shared=0 in non-shared and shared=1 in shared
-        assert "local shared = 0" in non_shared_script
-        assert "local shared = 1" in shared_script
-        
-        # Both can allocate the same key, but behavior should differ
-        assert allocator.malloc_key() == "key1"
-        assert shared_allocator.malloc_key() == "key1"
+
+        {
+            "locked_status": {
+                'key1': False,
+                'key2': not shared,
+                'key3': False
+            },
+            "pool_state": {
+                'key1': f'key3||{("key2" if shared else "")}||-1',
+                'key2': ('key1||||-1' if shared else '#ALLOCATED||#ALLOCATED||-1'),
+                'key3': '||key1||-1'
+            },
+            "head_key": 'key3',
+            "tail_key": ('key2' if shared else 'key1')
+        }
+
+        redis_allocator.free_keys("key2")
+        assert self.get_redis_pool_state(redis_allocator, redis_client) == self.generate_pool_state(
+            redis_client,
+            ['key3', 'key1', 'key2'],
+            []
+        )
+
+    def test_allocation_with_object(self, redis_allocator: RedisAllocator, redis_client: Redis,
+                                    test_object: _TestObject):
+        """Test allocation with object wrapper using Lua scripts and verify Redis state."""
+        shared = redis_allocator.shared
+        params = {"param1": "value1"}
+        # Determine potential bind key (though it shouldn't be created)
+
+        bind_key = redis_allocator._soft_bind_name(test_object.name) if test_object.name else None
+
+        # --- Allocation ---
+        alloc_obj = redis_allocator.malloc(timeout=30, obj=test_object, params=params)
+
+        # Verify object and Redis state after allocation
+        assert alloc_obj is not None
+        assert isinstance(alloc_obj, RedisAllocatorObject)
+        assert alloc_obj.key == "key1"
+        assert alloc_obj.obj == test_object
+        assert alloc_obj.params == params
+        assert test_object.config_key == alloc_obj.key
+        assert test_object.config_params == params
+        assert xor(shared, redis_client.exists(redis_allocator._key_str(alloc_obj.key)))
+        assert self.get_redis_pool_state(redis_allocator, redis_client) == self.generate_pool_state(
+            redis_client,
+            (['key2', 'key3', 'key1'] if shared else ['key2', 'key3']),
+            ([] if shared else ['key1'])
+        )
+
+        if bind_key is not None:
+            assert redis_client.exists(bind_key)
+        redis_allocator.free(alloc_obj)
+
+        # Verify state after freeing
+        assert not redis_allocator.is_locked(alloc_obj.key)
+        assert redis_client.exists(redis_allocator._key_str(alloc_obj.key)) == 0
+        assert alloc_obj.key in redis_allocator
+        assert self.get_redis_pool_state(redis_allocator, redis_client) == self.generate_pool_state(
+            redis_client,
+            ['key2', 'key3', 'key1'],
+            []
+        )
+
+    def test_gc_functionality(self, allocator_with_policy: RedisAllocator, redis_client: Redis):
+        """Test GC scenarios by interacting directly with Redis via Lua scripts."""
+        shared = allocator_with_policy.shared
+        with freeze_time("2024-01-01") as time:
+            alloc_key1 = allocator_with_policy.malloc_key(timeout=1)
+            assert alloc_key1 == "key1"
+            alloc_key2 = allocator_with_policy.malloc_key(timeout=1)
+            assert alloc_key2 == "key2"
+            alloc_key3 = allocator_with_policy.malloc_key(timeout=1)
+            assert alloc_key3 == "key3"
+            assert self.get_redis_pool_state(allocator_with_policy, redis_client) == self.generate_pool_state(
+                redis_client,
+                (['key1', 'key2', 'key3'] if shared else []),
+                ([] if shared else ['key1', 'key2', 'key3'])
+            )
+            alloc_key4 = allocator_with_policy.malloc_key(timeout=1)
+            if shared:
+                assert alloc_key4 == "key1"
+            else:
+                assert alloc_key4 is None
+                assert self.get_redis_pool_state(allocator_with_policy, redis_client) == self.generate_pool_state(
+                    redis_client,
+                    (['key2', 'key3', 'key1'] if shared else []),
+                    ([] if shared else ['key1', 'key2', 'key3'])
+                )
+            time.tick(1.1)
+            allocator_with_policy.gc()
+            assert self.get_redis_pool_state(allocator_with_policy, redis_client) == self.generate_pool_state(
+                redis_client,
+                (['key2', 'key3', 'key1'] if shared else ['key1', 'key2', 'key3']),
+                []
+            )
+            allocator_with_policy.extend(["key2"], timeout=2)
+            assert self.get_redis_pool_state(allocator_with_policy, redis_client) == self.generate_pool_state(
+                redis_client,
+                ([('key2', 2), 'key3', 'key1'] if shared else ['key1', ('key2', 2), 'key3']),
+                [])
+            alloc_key5 = allocator_with_policy.malloc_key(timeout=1)
+            assert alloc_key5 == ("key2" if shared else "key1")
+            time.tick(3)
+            allocator_with_policy.gc()
+            assert self.get_redis_pool_state(allocator_with_policy, redis_client) == self.generate_pool_state(
+                redis_client,
+                ['key3', 'key1'],
+                [])
+            assert allocator_with_policy.policy.updater.index == 0
+            assert len(allocator_with_policy) == 2
+            obj = allocator_with_policy.malloc()
+            assert len(allocator_with_policy) == 3
+            assert obj.key == "key3"
+            assert allocator_with_policy.policy.updater.index == 1
+            assert self.get_redis_pool_state(allocator_with_policy, redis_client) == self.generate_pool_state(
+                redis_client,
+                [('key1', 300), ('key2', 300), 'key3'] if shared else [('key1', 300), ('key2', 300)],
+                [] if shared else ['key3']
+            )
+            time.tick(600)
+            allocator_with_policy.gc()
+            allocator_with_policy.gc()  # some times should be called twice to remove the expired items
+            allocator_with_policy.policy.refresh_pool(allocator_with_policy)
+            assert len(allocator_with_policy) == 4
+            allocator_with_policy.gc()
+            assert self.get_redis_pool_state(allocator_with_policy, redis_client) == self.generate_pool_state(
+                redis_client,
+                ["key3", ("key4", 300), ("key5", 300), ("key6", 300)],
+                []
+            )
+
+
+
+    def test_soft_binding(self, redis_allocator: RedisAllocator, redis_client: Redis, test_object: _TestObject):
+        """Test soft binding mechanism with direct Redis interaction."""
+        shared = redis_allocator.shared
+        with freeze_time("2024-01-01") as time:
+            # Extend the pool
+            allocation1 = redis_allocator.malloc(timeout=30, obj=test_object, cache_timeout=10)
+            assert allocation1.key == "key1"
+            assert xor(shared, redis_allocator.is_locked("key1"))
+            bind_str = redis_allocator._soft_bind_name(test_object.name) if test_object.name else None
+            if bind_str is not None:
+                assert redis_client.get(bind_str) == "key1"
+                assert 1 < redis_client.ttl(bind_str) <= 10
+            redis_allocator.free(allocation1)
+
+            assert not redis_allocator.is_locked("key1")
+            allocation2 = redis_allocator.malloc(timeout=30, obj=test_object, cache_timeout=10)
+            assert allocation2.key == ("key1" if bind_str else "key2")
+            if shared:
+                if bind_str:
+                    state = ['key2', 'key3', 'key1'], []
+                else:
+                    state = ['key3', 'key1', 'key2'], []
+            else:
+                if bind_str:
+                    state = ['key2', 'key3'], ['key1']
+                else:
+                    state = ['key3', 'key1'], ['key2']
+            assert self.get_redis_pool_state(redis_allocator, redis_client) == self.generate_pool_state(
+                redis_client,
+                *state
+            )
+            time.tick(31)
+            redis_allocator.gc()
+            assert self.get_redis_pool_state(redis_allocator, redis_client) == self.generate_pool_state(
+                redis_client,
+                (['key2', 'key3', 'key1'] if bind_str else ['key3', 'key1', 'key2']),
+                []
+            )
+            allocation3 = redis_allocator.malloc_key(timeout=30, name="unbind", cache_timeout=10)
+            assert allocation3 == ("key2" if bind_str else "key3")
+            assert xor(shared, redis_allocator.is_locked(allocation3))
+            if bind_str:
+                if shared:
+                    state = ['key3', 'key1', 'key2'], []
+                else:
+                    state = ['key3', 'key1'], ['key2']
+            else:
+                if shared:
+                    state = ['key1', 'key2', 'key3'], []
+                else:
+                    state = ['key1', 'key2'], ['key3']
+            assert self.get_redis_pool_state(redis_allocator, redis_client) == self.generate_pool_state(redis_client, *state)