vectorwave 0.1.5__tar.gz → 0.1.6__tar.gz

{vectorwave-0.1.5/src/vectorwave.egg-info → vectorwave-0.1.6}/PKG-INFO

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

{vectorwave-0.1.5 → vectorwave-0.1.6}/pyproject.toml

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

vectorwave-0.1.6/src/tests/conftest.py

@@ -0,0 +1,27 @@
+import pytest
+import os
+import logging
+
+CACHE_FILE_PATH = ".vectorwave_functions_cache.json"
+logger = logging.getLogger(__name__)
+
+
+def _delete_cache():
+    """Helper function to remove the cache file if it exists."""
+    if os.path.exists(CACHE_FILE_PATH):
+        try:
+            os.remove(CACHE_FILE_PATH)
+        except OSError as e:
+            print(f"\n[CacheFixture Error] Failed to remove {CACHE_FILE_PATH}: {e}")
+
+
+@pytest.fixture(autouse=True, scope="function")
+def atomic_function_cache():
+    # --- SETUP (Before Test) ---
+    _delete_cache()
+
+    # --- Run the test ---
+    yield
+
+    # --- TEARDOWN (After Test) ---
+    _delete_cache()

{vectorwave-0.1.5 → vectorwave-0.1.6}/src/tests/database/test_db.py

@@ -355,6 +355,9 @@ def test_create_execution_schema_new(mock_vectorizer_none, test_settings):
     assert "status" in passed_props_map
     assert "duration_ms" in passed_props_map
 
+    assert "return_value" in passed_props_map
+    assert passed_props_map["return_value"].dataType == wvc.DataType.TEXT
+
     assert collection == mock_new_collection
 
 

{vectorwave-0.1.5 → vectorwave-0.1.6}/src/tests/models/test_db_config.py

@@ -148,4 +148,39 @@ def test_get_settings_loads_global_custom_values(mock_env_get, mock_open_file, m
     assert settings.global_custom_values["run_id"] == "test-run-123"
 
     # "EXPERIMENT_ID" should not be included as os.environ.get returned None.
-    assert "experiment_id" not in settings.global_custom_values
+    assert "experiment_id" not in settings.global_custom_values
+
+@patch('os.path.exists', return_value=False)
+def test_get_settings_parses_sensitive_keys(mock_exists, monkeypatch):
+    """
+    Tests whether the SENSITIVE_FIELD_NAMES environment variable is correctly parsed
+    and converted into a lowercase set (sensitive_keys).
+    """
+    monkeypatch.setenv("SENSITIVE_FIELD_NAMES", "password, Token, api_key,, secret ")
+
+    get_weaviate_settings.cache_clear()
+
+    # 2. Act
+    settings = get_weaviate_settings()
+
+    # 3. Assert
+    assert isinstance(settings.sensitive_keys, set)
+    assert len(settings.sensitive_keys) == 4 # 이제 4개가 맞습니다.
+    assert settings.sensitive_keys == {"password", "token", "api_key", "secret"}
+
+
+# [MODIFIED] @patch('os.environ.get', return_value=None) 제거, monkeypatch 인자 추가
+@patch('os.path.exists', return_value=False)
+def test_get_settings_sensitive_keys_default(mock_exists, monkeypatch): # <-- FIX: monkeypatch 사용
+    """
+    Test when there is no SENSITIVE_FIELD_NAMES environment variable set default
+    """
+    get_weaviate_settings.cache_clear()
+    monkeypatch.delenv("SENSITIVE_FIELD_NAMES", raising=False)
+
+    # 2. Act
+    settings = get_weaviate_settings()
+
+    # 3. Assert: check default for 5
+    assert settings.sensitive_keys == {"password", "api_key", "token", "secret", "auth_token"}
+    assert len(settings.sensitive_keys) == 5

{vectorwave-0.1.5 → vectorwave-0.1.6}/src/tests/monitoring/test_tracer.py

@@ -1,15 +1,18 @@
 import pytest
 from unittest.mock import MagicMock
+import json
+from datetime import datetime
 import time
 
-from vectorwave.monitoring.tracer import trace_root, trace_span
+from vectorwave.monitoring.tracer import trace_root, trace_span, _mask_and_serialize
+
 from vectorwave.models.db_config import WeaviateSettings
 
 # --- Import real functions for cache clearing ---
 from vectorwave.batch.batch import get_batch_manager as real_get_batch_manager
 from vectorwave.database.db import get_cached_client as real_get_cached_client
 from vectorwave.models.db_config import get_weaviate_settings as real_get_settings
-from vectorwave.monitoring.tracer import TraceCollector, current_tracer_var
+from vectorwave.monitoring.tracer import TraceCollector, current_tracer_var, current_span_id_var
 from vectorwave.monitoring.alert.base import BaseAlerter
 
 # Module paths to mock (adjust to your project structure if needed)
@@ -39,7 +42,8 @@ def mock_tracer_deps(monkeypatch):
         EXECUTION_COLLECTION_NAME="TestExecutions",
         custom_properties=None,  # Not important for this test
         global_custom_values={"run_id": "global-run-abc", "env": "test"},
-        failure_mapping={"ValueError": "INVALID_INPUT"}
+        failure_mapping={"ValueError": "INVALID_INPUT"},
+        sensitive_keys={"password", "token", "api_key"}
     )
     mock_get_settings = MagicMock(return_value=mock_settings)
 
@@ -73,16 +77,18 @@ def mock_tracer_deps(monkeypatch):
 
 def test_trace_root_and_span_success(mock_tracer_deps):
     """
-    Case 1: Success (Root + Span) - The span should be recorded successfully.
+    Case 1: Success (Root + Span)
+    [MODIFIED] Now also checks for parent_span_id hierarchy.
     """
-    mock_batch = mock_tracer_deps["batch"]
+    mock_batch = mock_tracer_deps["batch"].add_object  # Get the add_object mock
     mock_alerter = mock_tracer_deps["alerter"]
 
-    @trace_span
+    @trace_span  # Child
     def my_inner_span(x):
         return f"result: {x}"
 
-    @trace_root()
+    @trace_root()  # Root (sets up context)
+    @trace_span  # Root Span (logs itself)
     def my_workflow_root():
         return my_inner_span(x=10)
 
@@ -91,34 +97,48 @@ def test_trace_root_and_span_success(mock_tracer_deps):
 
     # --- Assert ---
     assert result == "result: 10"
-    mock_batch.add_object.assert_called_once()
+    # 2 calls: 1 (inner_span) + 1 (workflow_root)
+    assert mock_batch.call_count == 2
     mock_alerter.notify.assert_not_called()
 
-    args, kwargs = mock_batch.add_object.call_args
-    props = kwargs["properties"]
+    call_args_list = mock_batch.call_args_list
+    props_map = {
+        call.kwargs["properties"]["function_name"]: call.kwargs["properties"]
+        for call in call_args_list
+    }
+
+    assert "my_inner_span" in props_map
+    assert "my_workflow_root" in props_map
+
+    root_props = props_map["my_workflow_root"]
+    inner_props = props_map["my_inner_span"]
 
-    assert kwargs["collection"] == "TestExecutions"
-    assert props["status"] == "SUCCESS"
-    assert props["function_name"] == "my_inner_span"
-    assert props["error_message"] is None
-    assert kwargs["properties"]["error_code"] is None
-    assert "trace_id" in props
-    assert props["run_id"] == "global-run-abc"
-    assert props["env"] == "test"
+    # --- [NEW] Hierarchy Validation ---
+    assert root_props["parent_span_id"] is None  # Root span has no parent
+    assert inner_props["parent_span_id"] is not None
+    assert inner_props["parent_span_id"] == root_props["span_id"]  # Child's parent is Root
+
+    assert root_props["trace_id"] == inner_props["trace_id"]
+    assert root_props["status"] == "SUCCESS"
+    assert inner_props["status"] == "SUCCESS"
+    assert root_props["run_id"] == "global-run-abc"
+    assert inner_props["run_id"] == "global-run-abc"
 
 
 def test_trace_span_failure(mock_tracer_deps):
     """
-    Case 2: Failure (Root + Failing Span) - The span should be recorded with an ERROR status.
+    Case 2: Failure (Root + Failing Span)
+    Now checks hierarchy and logs both root (success) and child (error).
     """
-    mock_batch = mock_tracer_deps["batch"]
+    mock_batch = mock_tracer_deps["batch"].add_object  # Get the add_object mock
     mock_alerter = mock_tracer_deps["alerter"]
 
-    @trace_span
+    @trace_span  # Child (Failing)
     def my_failing_span():
         raise ValueError("This is a test error")
 
-    @trace_root()
+    @trace_root()  # Root (sets up context)
+    @trace_span  # Root Span (Success)
     def my_workflow_root_fail():
         my_failing_span()
 
@@ -127,34 +147,46 @@ def test_trace_span_failure(mock_tracer_deps):
         my_workflow_root_fail()
 
     # --- Assert (Log) ---
-    mock_batch.add_object.assert_called_once()
-    db_props = mock_batch.add_object.call_args.kwargs["properties"]
-    assert db_props["status"] == "ERROR"
-    assert "ValueError: This is a test error" in db_props["error_message"]
-    assert db_props["error_code"] == "INVALID_INPUT"
+    # 2 calls: 1 (root_fail - SUCCESS) + 1 (failing_span - ERROR)
+    assert mock_batch.call_count == 2
 
-    mock_alerter.notify.assert_called_once()
-    alert_props = mock_alerter.notify.call_args.args[0]
+    call_args_list = mock_batch.call_args_list
+    props_map = {
+        call.kwargs["properties"]["function_name"]: call.kwargs["properties"]
+        for call in call_args_list
+    }
 
-    args, kwargs = mock_batch.add_object.call_args
-    props = kwargs["properties"]
+    assert "my_workflow_root_fail" in props_map
+    assert "my_failing_span" in props_map
 
+    root_props = props_map["my_workflow_root_fail"]
+    failing_props = props_map["my_failing_span"]
 
-    assert alert_props == db_props
+    # Root Span Asserts (SUCCESS)
+    assert root_props["status"] == "ERROR"
+    assert root_props["parent_span_id"] is None
+
+    # Failing Span Asserts (ERROR)
+    assert failing_props["status"] == "ERROR"
+    assert "ValueError: This is a test error" in failing_props["error_message"]
+    assert failing_props["error_code"] == "INVALID_INPUT"
+    assert failing_props["parent_span_id"] == root_props["span_id"]
+    assert failing_props["run_id"] == "global-run-abc"
+
+    # Alerter Asserts
+    mock_alerter.notify.assert_called_once()
+    alert_props = mock_alerter.notify.call_args.args[0]
+
+    assert alert_props == failing_props  # Alerter was called with the failing span's properties
     assert alert_props["status"] == "ERROR"
     assert alert_props["error_code"] == "INVALID_INPUT"
-    assert props["status"] == "ERROR"
-    assert "ValueError: This is a test error" in props["error_message"]
-    assert kwargs["properties"]["error_code"] == "INVALID_INPUT"
-    assert props["function_name"] == "my_failing_span"
-    assert props["run_id"] == "global-run-abc"
 
 
 def test_span_without_root_does_nothing(mock_tracer_deps):
     """
     Case 3: Tracing disabled (Span only) - If there's no Root, nothing should be recorded.
     """
-    mock_batch = mock_tracer_deps["batch"]
+    mock_batch = mock_tracer_deps["batch"].add_object
 
     @trace_span
     def my_lonely_span():
@@ -165,60 +197,78 @@ def test_span_without_root_does_nothing(mock_tracer_deps):
 
     # --- Assert ---
     assert result == "lonely_result"
-    mock_batch.add_object.assert_not_called()
+    mock_batch.assert_not_called()
 
 
 def test_span_captures_attributes_and_overrides_globals(mock_tracer_deps):
     """
     Case 4/5: Attribute Capturing and Overriding
+    Checks hierarchy.
     """
-    mock_batch = mock_tracer_deps["batch"]
+    mock_batch = mock_tracer_deps["batch"].add_object
 
     class MyObject:
         def __str__(self): return "MyObjectInstance"
 
-    @trace_span(attributes_to_capture=["team", "priority", "run_id", "user_obj"])
-    def my_span_with_attrs(team, priority, run_id, user_obj, other_arg="default"):
+    @trace_span(attributes_to_capture=["team", "priority", "run_id", "user_obj", "password"])
+    def my_span_with_attrs(team, priority, run_id, user_obj, password, other_arg="default"):
         return "captured"
 
     @trace_root()
+    @trace_span  # Root span
     def my_workflow_root_attrs():
         return my_span_with_attrs(
             team="backend",
             priority=1,
             run_id="override-run-xyz",  # <-- This should override "global-run-abc"
             user_obj=MyObject(),
-            other_arg="should-be-ignored"
+            other_arg="should-be-ignored",
+            password="my_secret_password_123"
         )
 
     # --- Act ---
     my_workflow_root_attrs()
 
     # --- Assert ---
-    mock_batch.add_object.assert_called_once()
-    props = mock_batch.add_object.call_args.kwargs["properties"]
+    assert mock_batch.call_count == 2
+
+    props_map = {
+        call.kwargs["properties"]["function_name"]: call.kwargs["properties"]
+        for call in mock_batch.call_args_list
+    }
+    root_props = props_map["my_workflow_root_attrs"]
+    child_props = props_map["my_span_with_attrs"]
+
+    # Hierarchy
+    assert root_props["parent_span_id"] is None
+    assert child_props["parent_span_id"] == root_props["span_id"]
 
-    assert props["team"] == "backend"
-    assert props["priority"] == 1
-    assert props["user_obj"] == "MyObjectInstance"
-    assert props["run_id"] == "override-run-xyz"  # Overridden
-    assert props["env"] == "test"  # Non-overridden global remains
-    assert "other_arg" not in props
+    # Child properties (existing test)
+    assert child_props["team"] == "backend"
+    assert child_props["priority"] == 1
+    assert child_props["user_obj"] == "MyObjectInstance"
+    assert child_props["run_id"] == "override-run-xyz"  # Overridden
+    assert child_props["env"] == "test"  # Non-overridden global remains
+    assert "other_arg" not in child_props
+
+    assert "password" in child_props
+    assert child_props["password"] == "[MASKED]"
 
 
 def test_root_accepts_custom_trace_id(mock_tracer_deps):
     """
     Bonus: Test case for manually providing a 'trace_id'.
-    (This is the test that was fixed)
+    Checks hierarchy and trace_id propagation.
     """
-    mock_batch = mock_tracer_deps["batch"]
+    mock_batch = mock_tracer_deps["batch"].add_object
 
     @trace_span
     def my_inner_span():
         pass
 
-    @trace_root()
-    def my_workflow_root_custom_id():  # <-- ✅ FIXED: Removed 'trace_id' arg
+    @trace_root()  # Sets up context
+    @trace_span  # Root span
+    def my_workflow_root_custom_id():
         my_inner_span()
 
     # --- Act ---
@@ -226,16 +276,30 @@ def test_root_accepts_custom_trace_id(mock_tracer_deps):
     my_workflow_root_custom_id(trace_id="my-custom-trace-id-123")
 
     # --- Assert ---
-    mock_batch.add_object.assert_called_once()
-    props = mock_batch.add_object.call_args.kwargs["properties"]
+    assert mock_batch.call_count == 2
+
+    props_map = {
+        call.kwargs["properties"]["function_name"]: call.kwargs["properties"]
+        for call in mock_batch.call_args_list
+    }
+    root_props = props_map["my_workflow_root_custom_id"]
+    child_props = props_map["my_inner_span"]
 
     # Check if the trace_id was popped and injected correctly
-    assert props["trace_id"] == "my-custom-trace-id-123"
+    assert root_props["trace_id"] == "my-custom-trace-id-123"
+    assert child_props["trace_id"] == "my-custom-trace-id-123"
+
+    # Check hierarchy
+    assert root_props["parent_span_id"] is None
+    assert child_props["parent_span_id"] == root_props["span_id"]
 
 
 def test_trace_span_error_code_priority_1_custom_attr(mock_tracer_deps):
-    """Test (Priority 1) custom e.error_code attribute."""
-    mock_batch = mock_tracer_deps["batch"]
+    """
+    Test (Priority 1) custom e.error_code attribute.
+    Also sets and checks parent_span_id.
+    """
+    mock_batch = mock_tracer_deps["batch"].add_object
     tracer = TraceCollector(trace_id="test_trace_p1")
     tracer.settings = mock_tracer_deps["settings"]
 
@@ -243,21 +307,29 @@ def test_trace_span_error_code_priority_1_custom_attr(mock_tracer_deps):
     def my_custom_fail_function():
         raise CustomErrorWithCode("Test", "PAYMENT_FAILED_001")
 
-    token = current_tracer_var.set(tracer)
+    # Set up mock parent context
+    tracer_token = current_tracer_var.set(tracer)
+    parent_span_token = current_span_id_var.set("mock-parent-id-123")
+
     try:
         with pytest.raises(CustomErrorWithCode):
             my_custom_fail_function()
     finally:
-        current_tracer_var.reset(token)
+        current_span_id_var.reset(parent_span_token)
+        current_tracer_var.reset(tracer_token)
 
-    args, kwargs = mock_batch.add_object.call_args
+    args, kwargs = mock_batch.call_args
     assert kwargs["properties"]["status"] == "ERROR"
     assert kwargs["properties"]["error_code"] == "PAYMENT_FAILED_001"
+    assert kwargs["properties"]["parent_span_id"] == "mock-parent-id-123"
 
 
 def test_trace_span_error_code_priority_3_default_class_name(mock_tracer_deps):
-    """Test (Priority 3) default class name (KeyError is not in mapping)."""
-    mock_batch = mock_tracer_deps["batch"]
+    """
+    Test (Priority 3) default class name (KeyError is not in mapping).
+    Also sets and checks parent_span_id.
+    """
+    mock_batch = mock_tracer_deps["batch"].add_object
     tracer = TraceCollector(trace_id="test_trace_p3")
     tracer.settings = mock_tracer_deps["settings"]
 
@@ -265,13 +337,17 @@ def test_trace_span_error_code_priority_3_default_class_name(mock_tracer_deps):
     def my_key_error_function():
         _ = {}["missing_key"]  # Raises KeyError
 
-    token = current_tracer_var.set(tracer)
+    tracer_token = current_tracer_var.set(tracer)
+    parent_span_token = current_span_id_var.set("mock-parent-id-456")
+
     try:
         with pytest.raises(KeyError):
             my_key_error_function()
     finally:
-        current_tracer_var.reset(token)
+        current_span_id_var.reset(parent_span_token)
+        current_tracer_var.reset(tracer_token)
 
-    args, kwargs = mock_batch.add_object.call_args
+    args, kwargs = mock_batch.call_args
     assert kwargs["properties"]["status"] == "ERROR"
     assert kwargs["properties"]["error_code"] == "KeyError"
+    assert kwargs["properties"]["parent_span_id"] == "mock-parent-id-456"

{vectorwave-0.1.5 → vectorwave-0.1.6}/src/tests/search/test_execution_search.py

@@ -66,17 +66,22 @@ MockDateTime.fromisoformat = MagicMock(side_effect=datetime.fromisoformat)
 
 
 @patch('vectorwave.search.execution_search.datetime', MockDateTime)
-@patch('vectorwave.search.execution_search.find_executions', MagicMock(return_value=mock_db_errors))
-def test_find_recent_errors():
+@patch('vectorwave.search.execution_search.find_executions')
+def test_find_recent_errors(mock_find_executions):
     """
-    Tests if find_recent_errors (including manual filtering) works correctly.
+    Tests if find_recent_errors calls find_executions with the correct filters.
+    (The test no longer checks manual filtering, as filtering is delegated to the DB).
     """
     # 1. Run test
-    result = find_recent_errors(minutes_ago=10, error_codes=["INVALID_INPUT"])
+    find_recent_errors(minutes_ago=10, error_codes=["INVALID_INPUT"])
+
+    # 2. Verify find_executions was called correctly
+    call_args = mock_find_executions.call_args
+    filters_arg = call_args.kwargs['filters']
 
-    # 2. Verify result (if manual filtering worked correctly)
-    assert len(result) == 1  # Logs from 15 minutes ago should be filtered out
-    assert result[0]["error_code"] == "INVALID_INPUT"
+    assert filters_arg['status'] == 'ERROR'
+    assert filters_arg['error_code'] == 'INVALID_INPUT'
+    assert filters_arg['timestamp_utc__gte'] == expected_time_limit_iso
 
 
 @patch('vectorwave.search.execution_search.find_executions')

vectorwave-0.1.6/src/tests/utils/test_function_cahe.py

@@ -0,0 +1,126 @@
+import pytest
+import json
+from unittest.mock import patch, mock_open, ANY, MagicMock
+from vectorwave.utils.function_cache import FunctionCacheManager
+
+# --- 1. Tests for calculate_content_hash static method ---
+
+def test_calculate_content_hash_consistency():
+    """Tests that identical inputs always return the same hash."""
+    props1 = {"a": 1, "b": "test", "c": [1, 2, 3]}
+    props2 = {"a": 1, "b": "test", "c": [1, 2, 3]}
+
+    hash1 = FunctionCacheManager.calculate_content_hash("id1", props1)
+    hash2 = FunctionCacheManager.calculate_content_hash("id1", props2)
+
+    assert hash1 == hash2
+    assert len(hash1) == 64 # SHA256
+
+def test_calculate_content_hash_sensitivity_props():
+    """Tests that different properties return different hashes."""
+    props1 = {"a": 1, "b": "test"}
+    props2 = {"a": 1, "b": "changed"}
+
+    hash1 = FunctionCacheManager.calculate_content_hash("id1", props1)
+    hash2 = FunctionCacheManager.calculate_content_hash("id1", props2)
+
+    assert hash1 != hash2
+
+def test_calculate_content_hash_sensitivity_id():
+    """Tests that different identifiers return different hashes."""
+    props1 = {"a": 1}
+
+    hash1 = FunctionCacheManager.calculate_content_hash("id1", props1)
+    hash2 = FunctionCacheManager.calculate_content_hash("id2", props1)
+
+    assert hash1 != hash2
+
+def test_calculate_content_hash_order_invariance():
+    """
+    Tests that different dictionary key orders return the same hash,
+    due to json.dumps(sort_keys=True).
+    """
+    props1 = {"a": 1, "b": 2}
+    props2 = {"b": 2, "a": 1} # Changed order
+
+    hash1 = FunctionCacheManager.calculate_content_hash("id1", props1)
+    hash2 = FunctionCacheManager.calculate_content_hash("id1", props2)
+
+    assert hash1 == hash2
+
+
+# --- 2. Tests for __init__ and _load_cache ---
+
+@patch("os.path.exists", return_value=False)
+def test_init_cache_file_not_found(mock_exists):
+    """Tests that self.cache is initialized as an empty dict ({}) when the cache file is not found."""
+    manager = FunctionCacheManager()
+
+    mock_exists.assert_called_once_with("./.vectorwave_functions_cache.json")
+    assert manager.cache == {}
+
+@patch("os.path.exists", return_value=True)
+@patch("builtins.open", new_callable=mock_open, read_data='{"uuid_abc": "hash_123"}')
+def test_init_cache_file_loaded(mock_file, mock_exists):
+    """Tests that the cache file is loaded successfully."""
+    manager = FunctionCacheManager()
+
+    mock_exists.assert_called_once_with("./.vectorwave_functions_cache.json")
+    mock_file.assert_called_once_with("./.vectorwave_functions_cache.json", 'r', encoding='utf-8')
+    assert manager.cache == {"uuid_abc": "hash_123"}
+
+@patch("os.path.exists", return_value=True)
+@patch("builtins.open", new_callable=mock_open, read_data='{invalid_json')
+@patch("logging.Logger.warning") # Mock the logger
+def test_init_cache_invalid_json(mock_logger, mock_file, mock_exists):
+    """Tests that a warning is logged and cache is an empty dict ({}) if JSON parsing fails."""
+    manager = FunctionCacheManager()
+
+    assert manager.cache == {}
+    mock_logger.assert_called_once()
+    assert "Failed to load static function cache" in mock_logger.call_args[0][0]
+
+
+# --- 3. Tests for logic and saving ---
+
+@patch("os.path.exists", return_value=False)
+def test_is_cached_and_unchanged_logic(mock_exists):
+    """Tests the True/False logic of is_cached_and_unchanged."""
+    manager = FunctionCacheManager()
+    manager.cache = {
+        "uuid_A": "hash_A_123",
+        "uuid_B": "hash_B_123"
+    }
+
+    # 1. Cache Hit (Both UUID and hash match)
+    assert manager.is_cached_and_unchanged("uuid_A", "hash_A_123") == True
+
+    # 2. Cache Miss (UUID matches, but hash is different)
+    assert manager.is_cached_and_unchanged("uuid_B", "hash_B_456_NEW") == False
+
+    # 3. Cache Miss (UUID does not exist)
+    assert manager.is_cached_and_unchanged("uuid_C_NEW", "hash_C_123") == False
+
+@patch("os.path.exists", return_value=False)
+@patch("json.dump") # Mock json.dump
+@patch("builtins.open", new_callable=mock_open)
+def test_update_cache_calls_save(mock_file, mock_json_dump, mock_exists):
+    """Tests if update_cache updates self.cache and calls _save_cache."""
+    manager = FunctionCacheManager()
+    assert manager.cache == {}
+
+    manager.update_cache("uuid_new", "hash_new_123")
+
+    # 1. Check if the internal cache was updated
+    assert manager.cache == {"uuid_new": "hash_new_123"}
+
+    # 2. Check if _save_cache was called and attempted to write to the file
+    mock_file.assert_called_once_with("./.vectorwave_functions_cache.json", 'w', encoding='utf-8')
+
+    # 3. Check if json.dump was called with the correct arguments (indent, sort_keys)
+    mock_json_dump.assert_called_once_with(
+        {"uuid_new": "hash_new_123"}, # 1. The updated cache
+        ANY, # 2. The mock_file handle
+        indent=4,
+        sort_keys=True
+    )

{vectorwave-0.1.5 → vectorwave-0.1.6}/src/vectorwave/__init__.py

@@ -1,7 +1,7 @@
 from .core.decorator import vectorize
 
 from .database.db import initialize_database
-from .database.db_search import search_functions, search_executions
+from .database.db_search import search_functions, search_executions, search_errors_by_message
 from .monitoring.tracer import trace_span
 
 __all__ = [
@@ -9,5 +9,6 @@ __all__ = [
     'initialize_database',
     'search_functions',
     'search_executions',
+    'search_errors_by_message',
     'trace_span'
 ]