feat: adds tests and updates run-test.sh

Author: Matthieu-OD

literalai/api/__init__.py

@@ -1,5 +1,4 @@
 import logging
-import time
 import os
 from threading import Lock
 import uuid
@@ -147,20 +146,21 @@ class SharedPromptCache:
     """
     Thread-safe singleton cache for storing prompts with memory leak prevention.
     Only one instance will exist regardless of how many times it's instantiated.
-    Implements LRU eviction policy when cache reaches maximum size.
     """
     _instance = None
     _lock = Lock()
+    _shared_cache: dict[str, Prompt]
+    _name_index: dict[str, str]
+    _name_version_index: dict[tuple[str, int], str]
 
     def __new__(cls, max_size: int = 1000):
         with cls._lock:
             if cls._instance is None:
                 cls._instance = super().__new__(cls)
 
-                cls._instance._max_size = max_size
-                cls._instance._prompts: dict[str, Prompt] = {}
-                cls._instance._name_index: dict[str, str] = {}
-                cls._instance._name_version_index: dict[tuple[str, int], str] = {}
+                cls._instance._shared_cache = {}
+                cls._instance._name_index = {}
+                cls._instance._name_version_index = {}
         return cls._instance
 
     def get(
@@ -171,7 +171,6 @@ def get(
     ) -> Optional[Prompt]:
         """
         Retrieves a prompt using the most specific criteria provided.
-        Updates access time for LRU tracking.
         Lookup priority: id, name-version, name
         """
         if id and not isinstance(id, str):
@@ -196,7 +195,7 @@ def get(
 
     def put(self, prompt: Prompt):
         """
-        Stores a prompt in the cache, managing size limits with LRU eviction.
+        Stores a prompt in the cache.
         """
         if not isinstance(prompt, Prompt):
             raise TypeError("Expected a Prompt object")

literalai/api/prompt_helpers.py

@@ -5,6 +5,7 @@
 
 if TYPE_CHECKING:
     from literalai.api import LiteralAPI
+    from literalai.api import SharedPromptCache
 
 from literalai.api import gql
 

run-test.sh

@@ -1 +1 @@
-LITERAL_API_URL=http://localhost:3000 LITERAL_API_KEY=my-initial-api-key pytest -m e2e -s -v
+LITERAL_API_URL=http://localhost:3000 LITERAL_API_KEY=my-initial-api-key pytest -m e2e -s -v tests/e2e/ tests/unit/

tests/e2e/test_e2e.py

@@ -662,6 +662,20 @@ async def test_prompt(self, async_client: AsyncLiteralClient):
 
         assert messages[0]["content"] == expected
 
+    @pytest.mark.timeout(5)
+    async def test_prompt_cache(self, async_client: AsyncLiteralClient):
+        prompt = await async_client.api.get_prompt(name="Default", version=0)
+        assert prompt is not None
+        
+        original_key = async_client.api.api_key
+        async_client.api.api_key = "invalid-api-key"
+        
+        cached_prompt = await async_client.api.get_prompt(name="Default", version=0)
+        assert cached_prompt is not None
+        assert cached_prompt.id == prompt.id
+        
+        async_client.api.api_key = original_key
+
     @pytest.mark.timeout(5)
     async def test_prompt_ab_testing(self, client: LiteralClient):
         prompt_name = "Python SDK E2E Tests"

tests/unit/test_cache.py

@@ -4,17 +4,17 @@
 import random
 
 from literalai.prompt_engineering.prompt import Prompt
-from literalai.api import SharedPromptCache
+from literalai.api import SharedPromptCache, LiteralAPI, GenerationType
 
 def default_prompt(id: str = "1", name: str = "test", version: int = 1) -> Prompt:
     return Prompt(
-        api=None,
+        api=LiteralAPI(),
         id=id,
         name=name, 
         version=version,
         created_at="",
         updated_at="",
-        type="chat",
+        type="chat",  # type: ignore
         url="",
         version_desc=None,
         template_messages=[],
@@ -34,7 +34,7 @@ def test_singleton_instance():
 def test_get_empty_cache():
     """Test getting from empty cache returns None"""
     cache = SharedPromptCache()
-    cache.clear()  # Ensure clean state
+    cache.clear() 
 
     assert cache._prompts == {}
     assert cache._name_index == {}
@@ -90,12 +90,10 @@ def test_multiple_versions():
     cache.put(prompt1)
     cache.put(prompt2)
 
-    # Get specific versions
     assert cache.get(name="test", version=1) is prompt1
     assert cache.get(name="test", version=2) is prompt2
 
-    # Get by name should return latest version
-    assert cache.get(name="test") is prompt2  # Returns the last indexed version
+    assert cache.get(name="test") is prompt2 
 
 def test_clear_cache():
     """Test clearing the cache"""
@@ -114,7 +112,7 @@ def test_update_existing_prompt():
     cache.clear()
 
     prompt1 = default_prompt()
-    prompt2 = default_prompt(id="1", version=2) # Same ID, different version
+    prompt2 = default_prompt(id="1", version=2)
 
     cache.put(prompt1)
     cache.put(prompt2)
@@ -134,10 +132,8 @@ def test_lookup_priority():
     cache.put(prompt1)
     cache.put(prompt2)
 
-    # ID should take precedence
     assert cache.get(id="1", name="test", version=2) is prompt1
 
-    # Name-version should take precedence over name
     assert cache.get(name="test", version=2) is prompt2
 
 def test_thread_safety():