vectorwave 0.2.0__tar.gz → 0.2.2__tar.gz

{vectorwave-0.2.0/src/vectorwave.egg-info → vectorwave-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectorwave
-Version: 0.2.0
+Version: 0.2.2
 Summary: VectorWave: Seamless Auto-Vectorization Framework
 Author-email: junyeonggim <junyeonggim5@gmail.com>
 License-Expression: MIT

{vectorwave-0.2.0 → vectorwave-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vectorwave"
-version = "0.2.0"
+version = "0.2.02"
 authors = [
     { name = "junyeonggim", email = "junyeonggim5@gmail.com" },
 ]

vectorwave-0.2.2/src/tests/core/llm/test_token_usage.py

@@ -0,0 +1,112 @@
+import pytest
+from unittest.mock import MagicMock, patch
+from vectorwave.core.llm.openai_client import VectorWaveOpenAIClient
+
+@pytest.fixture
+def mock_deps(monkeypatch):
+    """
+    Mocks the dependencies (BatchManager, OpenAI, Settings) of VectorWaveOpenAIClient.
+    """
+    # 1. Mock BatchManager (Target for verifying token usage persistence)
+    mock_batch = MagicMock()
+    mock_batch.add_object = MagicMock()
+    mock_get_batch = MagicMock(return_value=mock_batch)
+    monkeypatch.setattr("vectorwave.core.llm.openai_client.get_batch_manager", mock_get_batch)
+
+    # 2. Mock Settings (Bypasses API Key check)
+    mock_settings = MagicMock()
+    mock_settings.OPENAI_API_KEY = "sk-test-key"
+    mock_get_settings = MagicMock(return_value=mock_settings)
+    monkeypatch.setattr("vectorwave.core.llm.openai_client.get_weaviate_settings", mock_get_settings)
+
+    # 3. Mock OpenAI Class (Bypasses actual API calls)
+    mock_openai_cls = MagicMock()
+    monkeypatch.setattr("vectorwave.core.llm.openai_client.OpenAI", mock_openai_cls)
+
+    # Note: Clearing the lru_cache for the singleton instance is typically
+    # needed if the client is imported globally. We assume the current test
+    # setup allows for fresh initialization here.
+
+    return {
+        "batch": mock_batch,
+        "openai_cls": mock_openai_cls
+    }
+
+def test_chat_completion_logs_token_usage(mock_deps):
+    """
+    [Case 1] Verify that token usage is logged as 'generation' type during chat completion.
+    """
+    # Arrange
+    # Get the mock client instance returned when OpenAI() is called
+    mock_client_instance = mock_deps["openai_cls"].return_value
+
+    # Mock OpenAI Response structure
+    mock_response = MagicMock()
+    mock_response.choices = [MagicMock(message=MagicMock(content="Test response"))]
+    mock_response.usage.total_tokens = 123  # Token count to test
+    mock_client_instance.chat.completions.create.return_value = mock_response
+
+    # Act
+    # Create a new client instance for the test
+    client = VectorWaveOpenAIClient()
+    result = client.create_chat_completion(
+        messages=[{"role": "user", "content": "Hi"}],
+        model="gpt-4-test",
+        category="test_chat_category"
+    )
+
+    # Assert
+    # 1. Verify that the function returns the expected result
+    assert result == "Test response"
+
+    # 2. Verify that BatchManager.add_object was called (log saved)
+    mock_batch = mock_deps["batch"]
+    mock_batch.add_object.assert_called_once()
+
+    # 3. Verify the properties of the saved log entry
+    call_kwargs = mock_batch.add_object.call_args.kwargs
+    props = call_kwargs["properties"]
+
+    assert call_kwargs["collection"] == "VectorWaveTokenUsage"
+    assert props["tokens"] == 123
+    assert props["model"] == "gpt-4-test"
+    assert props["category"] == "test_chat_category"
+    assert props["usage_type"] == "generation"
+
+def test_create_embedding_logs_token_usage(mock_deps):
+    """
+    [Case 2] Verify that token usage is logged as 'embedding' type during embedding creation.
+    """
+    # Arrange
+    mock_client_instance = mock_deps["openai_cls"].return_value
+
+    # Mock OpenAI Response structure
+    mock_response = MagicMock()
+    mock_response.data = [MagicMock(embedding=[0.1, 0.2, 0.3])]
+    mock_response.usage.total_tokens = 45  # Token count to test
+    mock_client_instance.embeddings.create.return_value = mock_response
+
+    # Act
+    client = VectorWaveOpenAIClient()
+    result = client.create_embedding(
+        text="Test text",
+        model="text-embedding-3-small",
+        category="test_embed_category"
+    )
+
+    # Assert
+    # 1. Verify that the function returns the expected result
+    assert result == [0.1, 0.2, 0.3]
+
+    # 2. Verify that BatchManager.add_object was called
+    mock_batch = mock_deps["batch"]
+    mock_batch.add_object.assert_called_once()
+
+    # 3. Verify the properties of the saved log entry
+    call_kwargs = mock_batch.add_object.call_args.kwargs
+    props = call_kwargs["properties"]
+
+    assert call_kwargs["collection"] == "VectorWaveTokenUsage"
+    assert props["tokens"] == 45
+    assert props["usage_type"] == "embedding"
+    assert props["category"] == "test_embed_category"

{vectorwave-0.2.0 → vectorwave-0.2.2}/src/tests/core/test_semantic_caching.py

@@ -25,46 +25,62 @@ def mock_caching_deps(monkeypatch):
     Mocks core dependencies for semantic caching testing.
     Mocking path: vectorwave.utils.return_caching_utils
     """
-    # 1. Mock BatchManager (Used to verify log saving)
+    # 1. Mock BatchManager
     mock_batch_manager = MagicMock()
     mock_batch_manager.add_object = MagicMock()
     mock_get_batch_manager = MagicMock(return_value=mock_batch_manager)
 
-    # 2. Mock Vectorizer (Provides dummy vector)
+    # 2. Mock Vectorizer
     mock_vectorizer = MagicMock()
-    mock_vectorizer.embed.return_value = [0.1, 0.2, 0.3] # Dummy vector
+    mock_vectorizer.embed.return_value = [0.1, 0.2, 0.3]
     mock_get_vectorizer = MagicMock(return_value=mock_vectorizer)
 
     # 3. Mock Settings
     mock_settings = WeaviateSettings(
         COLLECTION_NAME="TestFunctions",
         EXECUTION_COLLECTION_NAME="TestExecutions",
+        GOLDEN_COLLECTION_NAME="TestGolden",  # Ensure this is set
         global_custom_values={"run_id": "test-run-cache"},
-        sensitive_keys={"secret_key"} # For sensitive data masking test
+        sensitive_keys={"secret_key"}
     )
     mock_get_settings = MagicMock(return_value=mock_settings)
 
-    # 4. Mock Weaviate Client (For BatchManager initialization)
+    # 4. Mock Weaviate Client (Crucial Fix)
     mock_client = MagicMock()
+
+    # Setup mock for Golden Dataset query chain:
+    # client.collections.get().query.near_vector() -> returns empty objects list by default
+    mock_collection = MagicMock()
+    mock_query = MagicMock()
+    mock_response = MagicMock()
+    mock_response.objects = []  # Default to no golden hit
+
+    mock_query.near_vector.return_value = mock_response
+    mock_collection.query = mock_query
+    mock_client.collections.get.return_value = mock_collection
+
     mock_get_client = MagicMock(return_value=mock_client)
 
-    # 5. Mock DB Search (Core of caching)
-    mock_search_similar_execution = MagicMock(return_value=None) # Default value: Cache Miss
+    # 5. Mock DB Search (Standard Cache)
+    mock_search_similar_execution = MagicMock(return_value=None)
 
     # --- Apply Mocking ---
 
-    # Core/Decorator Dependencies
-    monkeypatch.setattr("vectorwave.core.decorator.get_batch_manager", mock_get_batch_manager)
-    monkeypatch.setattr("vectorwave.core.decorator.get_weaviate_settings", mock_get_settings)
-    monkeypatch.setattr("vectorwave.core.decorator.get_vectorizer", mock_get_vectorizer)
-
-    # Caching Utils Dependencies (Using the correct path)
     MOCK_PATH = "vectorwave.utils.return_caching_utils"
+
+    # [FIX] Mock get_cached_client in return_caching_utils
+    monkeypatch.setattr(f"{MOCK_PATH}.get_cached_client", mock_get_client)
+
     monkeypatch.setattr(f"{MOCK_PATH}.get_weaviate_settings", mock_get_settings)
     monkeypatch.setattr(f"{MOCK_PATH}.get_vectorizer", mock_get_vectorizer)
     monkeypatch.setattr(f"{MOCK_PATH}.search_similar_execution", mock_search_similar_execution)
 
-    # Tracer Dependencies (For successful log saving)
+    # Core/Decorator Dependencies
+    monkeypatch.setattr("vectorwave.core.decorator.get_batch_manager", mock_get_batch_manager)
+    monkeypatch.setattr("vectorwave.core.decorator.get_weaviate_settings", mock_get_settings)
+    monkeypatch.setattr("vectorwave.core.decorator.get_vectorizer", mock_get_vectorizer)
+
+    # Tracer Dependencies
     monkeypatch.setattr("vectorwave.monitoring.tracer.get_batch_manager", mock_get_batch_manager)
     monkeypatch.setattr("vectorwave.monitoring.tracer.get_weaviate_settings", mock_get_settings)
     monkeypatch.setattr("vectorwave.monitoring.tracer.get_vectorizer", mock_get_vectorizer)
@@ -79,12 +95,12 @@ def mock_caching_deps(monkeypatch):
     real_get_settings.cache_clear()
     real_get_vectorizer.cache_clear()
 
-
     return {
         "batch": mock_batch_manager,
         "vectorizer": mock_vectorizer,
         "search_cache": mock_search_similar_execution,
-        "settings": mock_settings
+        "settings": mock_settings,
+        "client": mock_client  # Return client if you need to manipulate golden cache results in tests
     }
 
 

vectorwave-0.2.2/src/tests/database/test_dataset.py

@@ -0,0 +1,97 @@
+import pytest
+from unittest.mock import MagicMock, patch
+import math
+from vectorwave.database.dataset import VectorWaveDatasetManager
+from vectorwave.models.db_config import WeaviateSettings
+
+@pytest.fixture
+def mock_dataset_deps(monkeypatch):
+    """Mocking dependencies for DatasetManager tests"""
+    # 1. Settings Mock
+    mock_settings = WeaviateSettings(
+        EXECUTION_COLLECTION_NAME="Executions",
+        GOLDEN_COLLECTION_NAME="GoldenData",
+        RECOMMENDATION_STEADY_MARGIN=0.1,
+        RECOMMENDATION_DISCOVERY_MARGIN=0.2
+    )
+    mock_get_settings = MagicMock(return_value=mock_settings)
+
+    # 2. Client & Collections Mock
+    mock_client = MagicMock()
+    mock_exec_col = MagicMock()
+    mock_golden_col = MagicMock()
+
+    def get_collection_side_effect(name):
+        if name == "Executions": return mock_exec_col
+        if name == "GoldenData": return mock_golden_col
+        return MagicMock()
+
+    mock_client.collections.get.side_effect = get_collection_side_effect
+    mock_get_client = MagicMock(return_value=mock_client)
+
+    # 3. Patching
+    monkeypatch.setattr("vectorwave.database.dataset.get_cached_client", mock_get_client)
+    monkeypatch.setattr("vectorwave.database.dataset.get_weaviate_settings", mock_get_settings)
+
+    return {
+        "exec_col": mock_exec_col,
+        "golden_col": mock_golden_col,
+        "settings": mock_settings
+    }
+
+def create_mock_obj(uuid_str, props=None, vector=None):
+    obj = MagicMock()
+    obj.uuid = uuid_str
+    obj.properties = props or {}
+    if vector:
+        obj.vector = {"default": vector}
+    return obj
+
+def test_register_as_golden_success(mock_dataset_deps):
+    """[Case 1] Test successful Golden Data registration"""
+    manager = VectorWaveDatasetManager()
+
+    # Arrange: Simulate successful retrieval of original log
+    mock_log = create_mock_obj("log-uuid-1", {"function_name": "test_func", "return_value": "res"}, vector=[0.1, 0.2])
+    mock_dataset_deps["exec_col"].query.fetch_object_by_id.return_value = mock_log
+
+    # Act
+    result = manager.register_as_golden("log-uuid-1", note="Best case")
+
+    # Assert
+    assert result is True
+    # Verify if insert was called on Golden Collection
+    mock_dataset_deps["golden_col"].data.insert.assert_called_once()
+    call_kwargs = mock_dataset_deps["golden_col"].data.insert.call_args.kwargs
+    assert call_kwargs["properties"]["original_uuid"] == "log-uuid-1"
+    assert call_kwargs["properties"]["note"] == "Best case"
+    assert call_kwargs["vector"] == [0.1, 0.2] # Check if vector was copied
+
+def test_recommend_candidates_logic(mock_dataset_deps):
+    """[Case 2] Test density-based recommendation logic (Steady/Discovery)"""
+    manager = VectorWaveDatasetManager()
+
+    # Arrange 1: Golden Data (Set reference point)
+    # Centroid: [1.0, 1.0], Avg Dist: 0.0 (Assuming all points are identical)
+    golden_vec = [1.0, 1.0]
+    golden_objs = [create_mock_obj("gold-1", {"original_uuid": "origin-1"}, golden_vec)]
+    mock_dataset_deps["golden_col"].query.fetch_objects.return_value.objects = golden_objs
+
+    # Cand A: [1.05, 1.05] -> Dist ≈ 0.07 (Steady Range: <= 0.1)
+    # Cand B: [1.2, 1.2]   -> Dist ≈ 0.28 (Discovery Range: 0.1 < d <= 0.3)
+    # Cand C: [2.0, 2.0]   -> Dist ≈ 1.41 (Ignore Range: > 0.3)
+    cand_a = create_mock_obj("cand-a", {"return_value": "A"}, [1.05, 1.05])
+    cand_b = create_mock_obj("cand-b", {"return_value": "B"}, [1.2, 1.2])
+    cand_c = create_mock_obj("cand-c", {"return_value": "C"}, [2.0, 2.0])
+
+    mock_dataset_deps["exec_col"].query.near_vector.return_value.objects = [cand_a, cand_b, cand_c]
+
+    # Act
+    recommendations = manager.recommend_candidates("test_func")
+
+    # Assert
+    assert len(recommendations) == 2
+    assert recommendations[0]["uuid"] == "cand-a"
+    assert recommendations[0]["type"] == "STEADY"
+    assert recommendations[1]["uuid"] == "cand-b"
+    assert recommendations[1]["type"] == "DISCOVERY"

{vectorwave-0.2.0 → vectorwave-0.2.2}/src/tests/utils/test_replayer.py

@@ -4,17 +4,19 @@ import asyncio
 import inspect
 from unittest.mock import MagicMock, patch
 from vectorwave.utils.replayer import VectorWaveReplayer
+from vectorwave.models.db_config import WeaviateSettings
 
 # --- 1. Mock Fixtures (Mock Environment Setup) ---
 
 @pytest.fixture
 def mock_replayer_deps(monkeypatch):
     """
-    Mocks the DB client and settings used by the Replayer.
+    Mocks the DB client and settings used by the Replayer (Default Setup).
     """
     # Settings Mock
     mock_settings = MagicMock()
     mock_settings.EXECUTION_COLLECTION_NAME = "VectorWaveExecutions"
+    mock_settings.GOLDEN_COLLECTION_NAME = "VectorWaveGoldenDataset"
 
     # Weaviate Client & Collection Mock
     mock_client = MagicMock()
@@ -26,7 +28,7 @@ def mock_replayer_deps(monkeypatch):
     mock_query.fetch_objects.return_value = MagicMock(objects=[])
     mock_collection.query = mock_query
 
-    # Data Operation Mock (Update, etc.)
+    # Data Operation Mock
     mock_data = MagicMock()
     mock_collection.data = mock_data
 
@@ -40,39 +42,58 @@ def mock_replayer_deps(monkeypatch):
         "data": mock_data
     }
 
+@pytest.fixture
+def mock_replayer_deps_v2(monkeypatch):
+    """
+    Mock fixture separating Golden and Execution collections for Priority Testing.
+    """
+    # Settings
+    mock_settings = WeaviateSettings(
+        EXECUTION_COLLECTION_NAME="Executions",
+        GOLDEN_COLLECTION_NAME="GoldenData"
+    )
+    mock_get_settings = MagicMock(return_value=mock_settings)
+
+    # Client & Collections
+    mock_client = MagicMock()
+    mock_exec_col = MagicMock()
+    mock_golden_col = MagicMock()
+
+    def get_collection_side_effect(name):
+        if name == "Executions": return mock_exec_col
+        if name == "GoldenData": return mock_golden_col
+        return MagicMock()
+
+    mock_client.collections.get.side_effect = get_collection_side_effect
+    mock_get_client = MagicMock(return_value=mock_client)
+
+    monkeypatch.setattr("vectorwave.utils.replayer.get_cached_client", mock_get_client)
+    monkeypatch.setattr("vectorwave.utils.replayer.get_weaviate_settings", mock_get_settings)
+
+    return {
+        "golden_col": mock_golden_col,
+        "exec_col": mock_exec_col
+    }
+
 def create_mock_log(uuid_str, inputs, return_value):
     """Mimics a log object retrieved from the database."""
     mock_obj = MagicMock()
     mock_obj.uuid = uuid_str
-
-    # Combine inputs and return_value into properties
     props = inputs.copy()
     props["return_value"] = json.dumps(return_value) if not isinstance(return_value, str) else return_value
     props["timestamp_utc"] = "2023-01-01T00:00:00Z"
-
     mock_obj.properties = props
     return mock_obj
 
 # --- 2. Test Cases ---
 
 def test_replay_success_match(mock_replayer_deps):
-    """
-    [Case 1] Successful Pass: Checks if the DB value matches the current function execution result.
-    """
-    # Arrange
+    """[Case 1] Successful Pass"""
     replayer = VectorWaveReplayer()
-
-    # 1. DB Mock Data (Input: a=1, b=2 -> Expected: 3)
     mock_logs = [create_mock_log("uuid-1", {"a": 1, "b": 2}, 3)]
     mock_replayer_deps["query"].fetch_objects.return_value.objects = mock_logs
 
-    # 2. Target Function Mock (Dynamic Import Mocking)
-    # If 'my_module.add' is called, this lambda function is executed
-    mock_func = MagicMock(return_value=3) # Actual result is also 3
-
-    # Set signature for replayer's inspect.signature check
-    # (Mock objects normally lack signatures, so we overwrite it)
-    import inspect
+    mock_func = MagicMock(return_value=3)
     mock_func.__signature__ = inspect.Signature([
         inspect.Parameter('a', inspect.Parameter.POSITIONAL_OR_KEYWORD),
         inspect.Parameter('b', inspect.Parameter.POSITIONAL_OR_KEYWORD)
@@ -83,30 +104,19 @@ def test_replay_success_match(mock_replayer_deps):
         setattr(mock_module, "add", mock_func)
         mock_import.return_value = mock_module
 
-        # Act
         result = replayer.replay("my_module.add", limit=1)
 
-    # Assert
     assert result["passed"] == 1
     assert result["failed"] == 0
-    mock_func.assert_called_with(a=1, b=2) # Verify call with correct arguments
-
+    mock_func.assert_called_with(a=1, b=2)
 
 def test_replay_failure_mismatch(mock_replayer_deps):
-    """
-    [Case 2] Failure: Checks for mismatch when the result value is different (Regression).
-    """
-    # Arrange
+    """[Case 2] Failure: Regression check"""
     replayer = VectorWaveReplayer()
-
-    # DB: 1 + 2 = 3
     mock_logs = [create_mock_log("uuid-2", {"a": 1, "b": 2}, 3)]
     mock_replayer_deps["query"].fetch_objects.return_value.objects = mock_logs
 
-    # Func: 1 + 2 = 99 (Bug!)
-    mock_func = MagicMock(return_value=99)
-
-    import inspect
+    mock_func = MagicMock(return_value=99) # Bug
     mock_func.__signature__ = inspect.Signature([
         inspect.Parameter('a', inspect.Parameter.POSITIONAL_OR_KEYWORD),
         inspect.Parameter('b', inspect.Parameter.POSITIONAL_OR_KEYWORD)
@@ -116,33 +126,20 @@ def test_replay_failure_mismatch(mock_replayer_deps):
         mock_module = MagicMock()
         setattr(mock_module, "add", mock_func)
         mock_import.return_value = mock_module
-
-        # Act
         result = replayer.replay("my_module.add")
 
-    # Assert
     assert result["passed"] == 0
     assert result["failed"] == 1
-    assert len(result["failures"]) == 1
     assert result["failures"][0]["expected"] == 3
     assert result["failures"][0]["actual"] == 99
 
-
 def test_replay_update_baseline(mock_replayer_deps):
-    """
-    [Case 3] Update: Checks updating the baseline when the result is different but update_baseline=True.
-    """
-    # Arrange
+    """[Case 3] Update Baseline"""
     replayer = VectorWaveReplayer()
-
-    # DB: Old value 'Old'
     mock_logs = [create_mock_log("uuid-3", {"msg": "Hi"}, "Old")]
     mock_replayer_deps["query"].fetch_objects.return_value.objects = mock_logs
 
-    # Func: New value 'New'
     mock_func = MagicMock(return_value="New")
-
-    import inspect
     mock_func.__signature__ = inspect.Signature([
         inspect.Parameter('msg', inspect.Parameter.POSITIONAL_OR_KEYWORD)
     ])
@@ -151,37 +148,22 @@ def test_replay_update_baseline(mock_replayer_deps):
         mock_module = MagicMock()
         setattr(mock_module, "greet", mock_func)
         mock_import.return_value = mock_module
-
-        # Act
-        # Set update_baseline=True
         result = replayer.replay("my_module.greet", update_baseline=True)
 
-    # Assert
     assert result["updated"] == 1
-    # Verify the DB update function was called
     mock_replayer_deps["data"].update.assert_called_once_with(
         uuid="uuid-3",
-        properties={"return_value": '"New"'} # JSON serialized string
+        properties={"return_value": '"New"'}
     )
 
-
 def test_replay_argument_filtering(mock_replayer_deps):
-    """
-    [Case 4] Argument Filtering: Checks that unnecessary metadata (like user_id) not in the function signature is removed.
-    """
-    # Arrange
+    """[Case 4] Argument Filtering"""
     replayer = VectorWaveReplayer()
-
-    # DB contains extraneous data like 'team', 'timestamp', etc.
     inputs = {"a": 10, "team": "billing", "priority": 1}
     mock_logs = [create_mock_log("uuid-4", inputs, 100)]
     mock_replayer_deps["query"].fetch_objects.return_value.objects = mock_logs
 
-    # Function only accepts 'a' as an argument
     mock_func = MagicMock(return_value=100)
-
-    import inspect
-    # Only 'a' is defined in the signature
     mock_func.__signature__ = inspect.Signature([
         inspect.Parameter('a', inspect.Parameter.POSITIONAL_OR_KEYWORD)
     ])
@@ -190,52 +172,76 @@ def test_replay_argument_filtering(mock_replayer_deps):
         mock_module = MagicMock()
         setattr(mock_module, "calc", mock_func)
         mock_import.return_value = mock_module
-
-        # Act
         replayer.replay("my_module.calc")
 
-    # Assert
-    # Should only be called with 'a=10', excluding 'team' and 'priority'
     mock_func.assert_called_once_with(a=10)
 
 def test_replay_async_function_execution_fixed(mock_replayer_deps):
-    """
-    [Case 5] Async Function Test (FIXED): Tests the async execution path using patching
-    of the import mechanism and executing the actual async function via asyncio.run.
-    """
-    # Arrange
+    """[Case 5] Async Function Test"""
     replayer = VectorWaveReplayer()
-
-    # 1. DB Mock Data
     inputs = {"a": 1, "b": 2}
     expected_result = 3
     mock_logs = [create_mock_log("uuid-async-1", inputs, expected_result)]
     mock_replayer_deps["query"].fetch_objects.return_value.objects = mock_logs
 
-    # 2. Define the actual ASYNC function for replayer to execute
     async def real_async_add(a, b):
-        # This function will be called and executed by asyncio.run
         await asyncio.sleep(0.001)
         return a + b
 
-    # Manually attach the signature for the replayer's inspection check to pass
     setattr(real_async_add, '__signature__', inspect.Signature([
         inspect.Parameter('a', inspect.Parameter.POSITIONAL_OR_KEYWORD),
         inspect.Parameter('b', inspect.Parameter.POSITIONAL_OR_KEYWORD)
     ]))
 
-    # 3. Patch importlib.import_module to return a mock module that contains the target function
     mock_module = MagicMock()
-    mock_module.async_add = real_async_add # The mock module must have the function
+    mock_module.async_add = real_async_add
 
     with patch("vectorwave.utils.replayer.importlib.import_module", return_value=mock_module):
-
-        # Act
-        # replayer.replay (sync function) calls asyncio.run(real_async_add(**inputs)) internally.
         result = replayer.replay("my_module.async_add", limit=1)
 
-    # Assert
-    # 1. The result should be successful and match the expected output
     assert result["passed"] == 1
     assert result["failed"] == 0
-    assert result["failures"] == []
+
+def test_replay_fetches_golden_first(mock_replayer_deps_v2):
+    """
+    [Case 6] Test if Replayer prioritizes fetching Golden Data
+    """
+    from vectorwave.utils.replayer import VectorWaveReplayer
+
+    # Arrange
+    # 1. Setup one Golden Data entry
+    golden_obj = MagicMock()
+    golden_obj.uuid = "golden-uuid"
+    golden_obj.properties = {"original_uuid": "orig-1", "return_value": "3"}
+    mock_replayer_deps_v2["golden_col"].query.fetch_objects.return_value.objects = [golden_obj]
+
+    # Retrieve original log (to get input values)
+    orig_log = MagicMock()
+    orig_log.properties = {"a": 1, "b": 2}
+    mock_replayer_deps_v2["exec_col"].query.fetch_object_by_id.return_value = orig_log
+
+    # 2. Leave Standard Data empty
+    mock_replayer_deps_v2["exec_col"].query.fetch_objects.return_value.objects = []
+
+    # Function Mock
+    mock_func = MagicMock(return_value=3)
+    mock_func.__signature__ = inspect.Signature([
+        inspect.Parameter('a', inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        inspect.Parameter('b', inspect.Parameter.POSITIONAL_OR_KEYWORD)
+    ])
+
+    # Act
+    replayer = VectorWaveReplayer()
+    with patch("vectorwave.utils.replayer.importlib.import_module") as mock_import:
+        mock_module = MagicMock()
+        setattr(mock_module, "add", mock_func)
+        mock_import.return_value = mock_module
+
+        result = replayer.replay("mod.add", limit=10)
+
+    # Assert
+    assert result["total"] == 1
+    # Verify that the Golden Collection was queried
+    mock_replayer_deps_v2["golden_col"].query.fetch_objects.assert_called_once()
+    # Verify that fetch_object_by_id was called to retrieve the original log
+    mock_replayer_deps_v2["exec_col"].query.fetch_object_by_id.assert_called_with("orig-1")