lib-x17-fintech 2.1.3__py3-none-any.whl

xfintech/data/common/tests/test_class_cache_all.py

@@ -0,0 +1,681 @@
+import pickle
+import tempfile
+from pathlib import Path
+
+from xfintech.data.common.cache import Cache
+
+# ==================== Cache Initialization Tests ====================
+
+
+def test_cache_init_default():
+    """Test Cache initialization with default values"""
+    cache = Cache()
+
+    assert cache.identifier is not None
+    assert len(cache.identifier) == 12
+    assert cache.path is not None
+    assert cache.path.exists()
+    assert cache.path.is_dir()
+
+
+def test_cache_init_custom_path():
+    """Test Cache initialization with custom path"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        custom_path = Path(tmpdir) / "custom_cache"
+        cache = Cache(path=custom_path)
+
+        assert cache.path.parent == custom_path
+        assert cache.path.exists()
+        assert str(custom_path) in str(cache.path)
+
+
+def test_cache_init_creates_directory():
+    """Test Cache creates directory if it doesn't exist"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        new_path = Path(tmpdir) / "new" / "nested" / "path"
+        cache = Cache(path=new_path)
+
+        assert cache.path.exists()
+        assert cache.path.is_dir()
+
+
+def test_cache_unique_identifiers():
+    """Test different Cache instances have unique identifiers"""
+    cache1 = Cache()
+    cache2 = Cache()
+
+    assert cache1.identifier != cache2.identifier
+    assert cache1.path != cache2.path
+
+
+def test_cache_identifier_format():
+    """Test identifier is 12-character hex string"""
+    cache = Cache()
+
+    assert len(cache.identifier) == 12
+    # Should be valid hex
+    int(cache.identifier, 16)
+
+
+# ==================== Resolve Methods Tests ====================
+
+
+def test_cache_resolve_identifier():
+    """Test _resolve_identifier generates valid UUID hex"""
+    cache = Cache()
+    identifier = cache._resolve_identifier()
+
+    assert isinstance(identifier, str)
+    assert len(identifier) == 12
+    # Should be valid hex
+    int(identifier, 16)
+
+
+def test_cache_resolve_path_with_none():
+    """Test _resolve_path with None uses default"""
+    cache = Cache()
+    path = cache._resolve_path(None)
+
+    assert path.exists()
+    assert str(Cache.DEFAULT_PARENT) in str(path)
+
+
+def test_cache_resolve_path_with_string():
+    """Test _resolve_path with string path"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache = Cache()
+        path = cache._resolve_path(tmpdir)
+
+        assert path.exists()
+        assert str(tmpdir) in str(path)
+        assert cache.identifier in str(path)
+
+
+def test_cache_resolve_path_with_path_object():
+    """Test _resolve_path with Path object"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cache = Cache()
+        path = cache._resolve_path(Path(tmpdir))
+
+        assert path.exists()
+        assert isinstance(path, Path)
+
+
+# ==================== Get Unit Tests ====================
+
+
+def test_cache_get_unit():
+    """Test get_unit returns correct path"""
+    cache = Cache()
+    unit_path = cache.get_unit("test_key")
+
+    assert isinstance(unit_path, Path)
+    assert unit_path.suffix == ".pkl"
+    assert unit_path.parent == cache.path
+
+
+def test_cache_get_unit_consistent():
+    """Test get_unit returns same path for same key"""
+    cache = Cache()
+
+    path1 = cache.get_unit("test_key")
+    path2 = cache.get_unit("test_key")
+
+    assert path1 == path2
+
+
+def test_cache_get_unit_different_keys():
+    """Test get_unit returns different paths for different keys"""
+    cache = Cache()
+
+    path1 = cache.get_unit("key1")
+    path2 = cache.get_unit("key2")
+
+    assert path1 != path2
+
+
+def test_cache_get_unit_uses_md5():
+    """Test get_unit uses MD5 hashing"""
+    cache = Cache()
+    unit_path = cache.get_unit("test_key")
+
+    # Verify it's a 32-character hex string (MD5)
+    assert len(unit_path.stem) == 32
+    int(unit_path.stem, 16)
+
+
+def test_cache_get_unit_handles_special_characters():
+    """Test get_unit handles special characters in keys"""
+    cache = Cache()
+
+    path1 = cache.get_unit("key with spaces")
+    path2 = cache.get_unit("key/with/slashes")
+    path3 = cache.get_unit("键中文")
+
+    assert path1.exists() or not path1.exists()  # Should not raise
+    assert path2.exists() or not path2.exists()
+    assert path3.exists() or not path3.exists()
+
+
+# ==================== Contains Tests ====================
+
+
+def test_cache_contains_false():
+    """Test __contains__ returns False for non-existent key"""
+    cache = Cache()
+
+    assert "nonexistent" not in cache
+
+
+def test_cache_contains_true():
+    """Test __contains__ returns True for existing key"""
+    cache = Cache()
+    cache.set("test_key", "test_value")
+
+    assert "test_key" in cache
+
+
+def test_cache_contains_after_delete():
+    """Test __contains__ returns False after deletion"""
+    cache = Cache()
+    cache.set("test_key", "test_value")
+
+    unit_path = cache.get_unit("test_key")
+    unit_path.unlink()
+
+    assert "test_key" not in cache
+
+
+# ==================== String Representation Tests ====================
+
+
+def test_cache_str():
+    """Test __str__ returns path string"""
+    cache = Cache()
+
+    str_repr = str(cache)
+
+    assert isinstance(str_repr, str)
+    assert str(cache.path) == str_repr
+
+
+def test_cache_repr():
+    """Test __repr__ returns detailed representation"""
+    cache = Cache()
+
+    repr_str = repr(cache)
+
+    assert "Cache" in repr_str
+    assert "path=" in repr_str
+    assert str(cache.path) in repr_str
+
+
+# ==================== Get Tests ====================
+
+
+def test_cache_get_nonexistent():
+    """Test get returns None for non-existent key"""
+    cache = Cache()
+
+    result = cache.get("nonexistent")
+
+    assert result is None
+
+
+def test_cache_get_existing():
+    """Test get returns value for existing key"""
+    cache = Cache()
+    cache.set("test_key", "test_value")
+
+    result = cache.get("test_key")
+
+    assert result == "test_value"
+
+
+def test_cache_get_with_dict():
+    """Test get works with dictionary values"""
+    cache = Cache()
+    test_data = {"key": "value", "number": 42}
+    cache.set("dict_key", test_data)
+
+    result = cache.get("dict_key")
+
+    assert result == test_data
+    assert result["key"] == "value"
+    assert result["number"] == 42
+
+
+def test_cache_get_with_list():
+    """Test get works with list values"""
+    cache = Cache()
+    test_data = [1, 2, 3, "four", {"five": 5}]
+    cache.set("list_key", test_data)
+
+    result = cache.get("list_key")
+
+    assert result == test_data
+
+
+def test_cache_get_with_none_value():
+    """Test get works with None as value"""
+    cache = Cache()
+    cache.set("none_key", None)
+
+    result = cache.get("none_key")
+
+    # This is tricky - None value vs non-existent key
+    # Current implementation will return None for both
+    assert result is None
+
+
+def test_cache_get_corrupted_file():
+    """Test get returns None for corrupted cache file"""
+    cache = Cache()
+    unit_path = cache.get_unit("corrupted")
+
+    # Create corrupted file
+    with unit_path.open("w") as f:
+        f.write("not valid pickle data")
+
+    result = cache.get("corrupted")
+
+    assert result is None
+
+
+def test_cache_get_empty_file():
+    """Test get returns None for empty cache file"""
+    cache = Cache()
+    unit_path = cache.get_unit("empty")
+
+    # Create empty file
+    unit_path.touch()
+
+    result = cache.get("empty")
+
+    assert result is None
+
+
+# ==================== Set Tests ====================
+
+
+def test_cache_set_basic():
+    """Test set stores value"""
+    cache = Cache()
+
+    cache.set("test_key", "test_value")
+
+    unit_path = cache.get_unit("test_key")
+    assert unit_path.exists()
+
+
+def test_cache_set_overwrites():
+    """Test set overwrites existing value"""
+    cache = Cache()
+
+    cache.set("test_key", "first_value")
+    cache.set("test_key", "second_value")
+
+    result = cache.get("test_key")
+    assert result == "second_value"
+
+
+def test_cache_set_multiple_keys():
+    """Test set works with multiple keys"""
+    cache = Cache()
+
+    cache.set("key1", "value1")
+    cache.set("key2", "value2")
+    cache.set("key3", "value3")
+
+    assert cache.get("key1") == "value1"
+    assert cache.get("key2") == "value2"
+    assert cache.get("key3") == "value3"
+
+
+def test_cache_set_complex_objects():
+    """Test set works with complex Python objects"""
+    cache = Cache()
+
+    test_data = {
+        "string": "text",
+        "number": 42,
+        "float": 3.14,
+        "list": [1, 2, 3],
+        "nested": {"inner": "value"},
+        "tuple": (1, 2, 3),
+    }
+
+    cache.set("complex", test_data)
+    result = cache.get("complex")
+
+    assert result == test_data
+
+
+def test_cache_set_creates_pickle_file():
+    """Test set creates valid pickle file"""
+    cache = Cache()
+
+    cache.set("test_key", {"data": "value"})
+
+    unit_path = cache.get_unit("test_key")
+    with unit_path.open("rb") as f:
+        payload = pickle.load(f)
+
+    assert "value" in payload
+    assert payload["value"] == {"data": "value"}
+
+
+# ==================== List Tests ====================
+
+
+def test_cache_list_empty():
+    """Test list returns empty list for new cache"""
+    cache = Cache()
+
+    keys = cache.list()
+
+    assert isinstance(keys, list)
+    assert len(keys) == 0
+
+
+def test_cache_list_with_items():
+    """Test list returns all cached keys"""
+    cache = Cache()
+
+    cache.set("key1", "value1")
+    cache.set("key2", "value2")
+    cache.set("key3", "value3")
+
+    keys = cache.list()
+
+    assert len(keys) == 3
+
+
+def test_cache_list_returns_hashes():
+    """Test list returns MD5 hashes not original keys"""
+    cache = Cache()
+
+    cache.set("original_key", "value")
+
+    keys = cache.list()
+
+    assert len(keys) == 1
+    # Keys are MD5 hashes (32 hex chars)
+    assert len(keys[0]) == 32
+
+
+def test_cache_list_after_clear():
+    """Test list returns empty after clear"""
+    cache = Cache()
+
+    cache.set("key1", "value1")
+    cache.set("key2", "value2")
+    cache.clear()
+
+    keys = cache.list()
+
+    assert len(keys) == 0
+
+
+# ==================== Clear Tests ====================
+
+
+def test_cache_clear_empty():
+    """Test clear on empty cache doesn't raise error"""
+    cache = Cache()
+
+    cache.clear()  # Should not raise
+
+
+def test_cache_clear_removes_files():
+    """Test clear removes all cache files"""
+    cache = Cache()
+
+    cache.set("key1", "value1")
+    cache.set("key2", "value2")
+
+    cache.clear()
+
+    assert len(list(cache.path.glob("*.pkl"))) == 0
+
+
+def test_cache_clear_verifies_removal():
+    """Test clear actually removes accessible files"""
+    cache = Cache()
+
+    cache.set("key1", "value1")
+    cache.set("key2", "value2")
+
+    cache.clear()
+
+    assert cache.get("key1") is None
+    assert cache.get("key2") is None
+
+
+def test_cache_clear_handles_errors():
+    """Test clear handles errors gracefully"""
+    cache = Cache()
+    cache.set("test", "value")
+
+    # Clear should not raise even if files can't be deleted
+    cache.clear()  # Should complete without exception
+
+
+# ==================== Describe / To Dict Tests ====================
+
+
+def test_cache_describe():
+    """Test describe returns dict"""
+    cache = Cache()
+
+    result = cache.describe()
+
+    assert isinstance(result, dict)
+
+
+def test_cache_describe_equals_to_dict():
+    """Test describe returns same as to_dict"""
+    cache = Cache()
+
+    describe_result = cache.describe()
+    to_dict_result = cache.to_dict()
+
+    assert describe_result == to_dict_result
+
+
+def test_cache_to_dict_structure():
+    """Test to_dict returns expected structure"""
+    cache = Cache()
+
+    result = cache.to_dict()
+
+    assert "identifier" in result
+    assert "path" in result
+    assert "units" in result
+
+
+def test_cache_to_dict_values():
+    """Test to_dict returns correct values"""
+    cache = Cache()
+
+    result = cache.to_dict()
+
+    assert result["identifier"] == cache.identifier
+    assert result["path"] == str(cache.path)
+    assert isinstance(result["units"], list)
+
+
+def test_cache_to_dict_with_data():
+    """Test to_dict includes cache items"""
+    cache = Cache()
+
+    cache.set("key1", "value1")
+    cache.set("key2", "value2")
+
+    result = cache.to_dict()
+
+    assert len(result["units"]) == 2
+
+
+# ==================== Integration Tests ====================
+
+
+def test_cache_full_workflow():
+    """Test complete cache workflow"""
+    cache = Cache()
+
+    # Set values
+    cache.set("user", {"name": "张三", "age": 30})
+    cache.set("items", [1, 2, 3, 4, 5])
+
+    # Check existence
+    assert "user" in cache
+    assert "items" in cache
+    assert "nonexistent" not in cache
+
+    # Get values
+    user = cache.get("user")
+    items = cache.get("items")
+
+    assert user["name"] == "张三"
+    assert len(items) == 5
+
+    # List keys
+    keys = cache.list()
+    assert len(keys) == 2
+
+    # Get info
+    info = cache.to_dict()
+    assert len(info["units"]) == 2
+
+    # Clear
+    cache.clear()
+    assert len(cache.list()) == 0
+
+
+def test_cache_persistence():
+    """Test cache persists across instances with same path"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        custom_path = Path(tmpdir)
+
+        # Create cache and set value
+        cache1 = Cache(path=custom_path)
+        identifier1 = cache1.identifier
+        cache1.set("persist_key", "persist_value")
+
+        # Create new cache with same base path
+        cache2 = Cache(path=custom_path / identifier1)
+        cache2.get("persist_key")
+
+        # Note: This won't work because each Cache gets unique identifier
+        # But the files exist in the directory
+        assert len(list((custom_path / identifier1).glob("*.pkl"))) > 0
+
+
+def test_cache_isolation():
+    """Test different caches are isolated"""
+    cache1 = Cache()
+    cache2 = Cache()
+
+    cache1.set("key", "value1")
+    cache2.set("key", "value2")
+
+    assert cache1.get("key") == "value1"
+    assert cache2.get("key") == "value2"
+
+
+def test_cache_handles_concurrent_operations():
+    """Test cache handles multiple operations in sequence"""
+    cache = Cache()
+
+    # Rapid set/get operations
+    for i in range(10):
+        cache.set(f"key{i}", f"value{i}")
+
+    # Verify all stored
+    for i in range(10):
+        assert cache.get(f"key{i}") == f"value{i}"
+
+    # List should have all
+    assert len(cache.list()) == 10
+
+
+def test_cache_large_value():
+    """Test cache handles large values"""
+    cache = Cache()
+
+    # Large list
+    large_data = list(range(10000))
+    cache.set("large", large_data)
+
+    result = cache.get("large")
+
+    assert len(result) == 10000
+    assert result[0] == 0
+    assert result[-1] == 9999
+
+
+def test_cache_unicode_keys():
+    """Test cache handles unicode in keys"""
+    cache = Cache()
+
+    cache.set("中文键", "中文值")
+    cache.set("🔑emoji", "😀emoji_value")
+
+    assert cache.get("中文键") == "中文值"
+    assert cache.get("🔑emoji") == "😀emoji_value"
+
+
+def test_cache_update_value():
+    """Test updating cached value multiple times"""
+    cache = Cache()
+
+    cache.set("counter", 0)
+
+    for i in range(1, 6):
+        cache.set("counter", i)
+
+    result = cache.get("counter")
+    assert result == 5
+
+
+def test_cache_binary_data():
+    """Test cache handles binary data"""
+    cache = Cache()
+
+    binary_data = b"\x00\x01\x02\x03\x04\x05"
+    cache.set("binary", binary_data)
+
+    result = cache.get("binary")
+    assert result == binary_data
+
+
+def test_cache_nested_structures():
+    """Test cache handles deeply nested structures"""
+    cache = Cache()
+
+    nested = {"level1": {"level2": {"level3": {"level4": {"data": [1, 2, 3]}}}}}
+
+    cache.set("nested", nested)
+    result = cache.get("nested")
+
+    assert result["level1"]["level2"]["level3"]["level4"]["data"] == [1, 2, 3]
+
+
+def test_cache_custom_path_cleanup():
+    """Test cache with custom path cleans up properly"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        custom_path = Path(tmpdir) / "test_cache"
+        cache = Cache(path=custom_path)
+
+        cache.set("key1", "value1")
+        cache.set("key2", "value2")
+
+        # Verify files created
+        assert len(list(cache.path.glob("*.pkl"))) == 2
+
+        # Clear
+        cache.clear()
+
+        # Verify files removed
+        assert len(list(cache.path.glob("*.pkl"))) == 0