LLM-Driven Extraction of Unstructured Data — Built for API Deployments & ETL Pipeline Workflows
Python ai-agentsdata-engineeringdocument-aigenerative-aiidpjson-extractionllmmcp-serverocrpdf-extractionprompt-engineeringstructured-output
"""Unit tests for IDE Callback Worker tasks.
Tests all 4 callback tasks (ide_index_complete, ide_index_error,
ide_prompt_complete, ide_prompt_error) by mocking the PromptStudioAPIClient
and verifying correct API calls, websocket emissions, return values,
and error handling.
Tasks are called as plain functions (bypassing Celery task machinery)
since we're testing callback logic, not Celery routing.
"""
import time
from unittest.mock import MagicMock, call, patch
import pytest
# Patch targets
_PATCH_GET_CLIENT = "ide_callback.tasks._get_api_client"
_PATCH_EMIT_WS = "ide_callback.tasks._emit_websocket"
_PATCH_ASYNC_RESULT = "celery.result.AsyncResult"
_PATCH_GET_PLUGIN = "client_plugin_registry.get_client_plugin"
# ---------------------------------------------------------------------------
# Fixtures
# ---------------------------------------------------------------------------
@pytest.fixture
def mock_api():
"""Return a mocked PromptStudioAPIClient with default success responses."""
api = MagicMock()
api.post.return_value = {"success": True}
api.get.return_value = {"success": True, "data": {}}
api.mark_document_indexed.return_value = {"success": True}
api.remove_document_indexing.return_value = {"success": True}
api.update_index_manager.return_value = {"success": True}
api.update_prompt_output.return_value = {"success": True, "data": [{"id": "out1"}]}
api.notify_hubspot.return_value = {"success": True}
api.get_summary_index_key.return_value = {
"success": True,
"data": {"doc_id": "summary-doc-id-hash"},
}
return api
@pytest.fixture
def base_index_kwargs():
"""Standard callback_kwargs for index tasks."""
return {
"log_events_id": "room-123",
"org_id": "org-1",
"user_id": "user-1",
"document_id": "doc-1",
"doc_id_key": "key-abc",
"profile_manager_id": "profile-1",
"executor_task_id": "task-1",
"tool_id": "tool-1",
}
@pytest.fixture
def base_prompt_kwargs():
"""Standard callback_kwargs for prompt tasks."""
return {
"log_events_id": "room-456",
"org_id": "org-1",
"operation": "fetch_response",
"run_id": "run-1",
"document_id": "doc-1",
"prompt_ids": ["p1", "p2"],
"profile_manager_id": "profile-1",
"is_single_pass": False,
"executor_task_id": "task-2",
"tool_id": "tool-2",
"dispatch_time": 0,
}
@pytest.fixture
def success_result():
"""Standard executor success result dict."""
return {
"success": True,
"data": {"doc_id": "computed-doc-id"},
}
@pytest.fixture
def failure_result():
"""Standard executor failure result dict."""
return {
"success": False,
"error": "Executor blew up",
}
@pytest.fixture
def no_client_plugins():
"""Pin plugin lookup to the OSS answer for callbacks that aren't testing it.
Left live, a tree with the plugins installed makes a real HTTP call that only
fails after a multi-second connect timeout.
"""
with patch(_PATCH_GET_PLUGIN, return_value=None):
yield
# ---------------------------------------------------------------------------
# TestIdeIndexComplete
# ---------------------------------------------------------------------------
class TestIdeIndexComplete:
"""Tests for ide_index_complete task."""
def _call(self, result_dict, callback_kwargs=None):
from ide_callback.tasks import ide_index_complete
return ide_index_complete(result_dict, callback_kwargs)
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_success_path(self, mock_get_client, mock_emit_ws, mock_api, base_index_kwargs, success_result):
mock_get_client.return_value = mock_api
result = self._call(success_result, base_index_kwargs)
assert result["message"] == "Document indexed successfully."
assert result["document_id"] == "doc-1"
# mark_document_indexed called with correct args
mock_api.mark_document_indexed.assert_called_once_with(
org_id="org-1", user_id="user-1", doc_id_key="key-abc",
doc_id="computed-doc-id", organization_id="org-1",
)
# update_index_manager called for primary profile
mock_api.update_index_manager.assert_called_once_with(
document_id="doc-1", profile_manager_id="profile-1",
doc_id="computed-doc-id", organization_id="org-1",
)
# websocket emitted with success
mock_emit_ws.assert_called_once()
ws_call = mock_emit_ws.call_args
assert ws_call[1]["room"] == "room-123"
assert ws_call[1]["event"] == "prompt_studio_result"
ws_data = ws_call[1]["data"]
assert ws_data["status"] == "completed"
assert ws_data["operation"] == "index_document"
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_executor_failure(self, mock_get_client, mock_emit_ws, mock_api, base_index_kwargs, failure_result):
mock_get_client.return_value = mock_api
result = self._call(failure_result, base_index_kwargs)
assert result["status"] == "failed"
assert result["error"] == "Executor blew up"
# Should clean up indexing flag
mock_api.remove_document_indexing.assert_called_once()
# Should NOT mark as indexed
mock_api.mark_document_indexed.assert_not_called()
# Should emit error websocket
mock_emit_ws.assert_called_once()
ws_data = mock_emit_ws.call_args[1]["data"]
assert ws_data["status"] == "failed"
assert ws_data["error"] == "Executor blew up"
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_no_profile_manager(self, mock_get_client, mock_emit_ws, mock_api, base_index_kwargs, success_result):
"""When profile_manager_id is None, skip update_index_manager."""
mock_get_client.return_value = mock_api
base_index_kwargs["profile_manager_id"] = None
result = self._call(success_result, base_index_kwargs)
assert result["document_id"] == "doc-1"
mock_api.mark_document_indexed.assert_called_once()
mock_api.update_index_manager.assert_not_called()
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_summary_indexing(self, mock_get_client, mock_emit_ws, mock_api, base_index_kwargs, success_result):
"""Summary profile triggers get_summary_index_key + update_index_manager."""
mock_get_client.return_value = mock_api
base_index_kwargs["summary_profile_id"] = "summary-prof-1"
base_index_kwargs["summarize_file_path"] = "/path/to/summary.txt"
result = self._call(success_result, base_index_kwargs)
assert result["document_id"] == "doc-1"
# summary index key fetched via backend endpoint
mock_api.get_summary_index_key.assert_called_once_with(
summary_profile_id="summary-prof-1",
summarize_file_path="/path/to/summary.txt",
org_id="org-1",
organization_id="org-1",
)
# update_index_manager called twice: primary + summary
assert mock_api.update_index_manager.call_count == 2
summary_call = mock_api.update_index_manager.call_args_list[1]
assert summary_call == call(
document_id="doc-1",
profile_manager_id="summary-prof-1",
doc_id="summary-doc-id-hash",
is_summary=True,
organization_id="org-1",
)
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_summary_indexing_failure_non_fatal(self, mock_get_client, mock_emit_ws, mock_api, base_index_kwargs, success_result):
"""Summary index failure doesn't prevent success return."""
mock_get_client.return_value = mock_api
base_index_kwargs["summary_profile_id"] = "summary-prof-1"
base_index_kwargs["summarize_file_path"] = "/path/to/summary.txt"
mock_api.get_summary_index_key.side_effect = Exception("backend down")
result = self._call(success_result, base_index_kwargs)
# Primary indexing still succeeds
assert result["message"] == "Document indexed successfully."
mock_api.mark_document_indexed.assert_called_once()
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_doc_id_falls_back_to_key(self, mock_get_client, mock_emit_ws, mock_api, base_index_kwargs):
"""When result has no doc_id, falls back to doc_id_key."""
mock_get_client.return_value = mock_api
result_dict = {"success": True, "data": {}}
result = self._call(result_dict, base_index_kwargs)
assert result["document_id"] == "doc-1"
mock_api.mark_document_indexed.assert_called_once_with(
org_id="org-1", user_id="user-1", doc_id_key="key-abc",
doc_id="key-abc", organization_id="org-1",
)
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_exception_emits_error_and_reraises(self, mock_get_client, mock_emit_ws, mock_api, base_index_kwargs, success_result):
"""Unexpected exception emits error websocket and re-raises."""
mock_get_client.return_value = mock_api
mock_api.mark_document_indexed.side_effect = RuntimeError("DB down")
with pytest.raises(RuntimeError, match="DB down"):
self._call(success_result, base_index_kwargs)
mock_emit_ws.assert_called()
last_ws = mock_emit_ws.call_args_list[-1]
assert last_ws[1]["data"]["status"] == "failed"
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_none_callback_kwargs(self, mock_get_client, mock_emit_ws, mock_api, success_result):
"""Passing None for callback_kwargs uses defaults without crashing."""
mock_get_client.return_value = mock_api
result = self._call(success_result, None)
assert result["document_id"] == ""
mock_api.mark_document_indexed.assert_called_once()
# ---------------------------------------------------------------------------
# TestIdeIndexError
# ---------------------------------------------------------------------------
class TestIdeIndexError:
"""Tests for ide_index_error task."""
def _call(self, failed_task_id, callback_kwargs=None):
from ide_callback.tasks import ide_index_error
return ide_index_error(failed_task_id, callback_kwargs)
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_error_with_result(self, mock_get_client, mock_emit_ws, mock_api, base_index_kwargs):
"""Retrieves error message from AsyncResult when available."""
mock_get_client.return_value = mock_api
mock_async_result = MagicMock()
mock_async_result.result = ValueError("Index OOM")
with patch(_PATCH_ASYNC_RESULT, return_value=mock_async_result):
self._call("failed-task-id-1", base_index_kwargs)
mock_api.remove_document_indexing.assert_called_once_with(
org_id="org-1", user_id="user-1", doc_id_key="key-abc",
organization_id="org-1",
)
mock_emit_ws.assert_called_once()
ws_data = mock_emit_ws.call_args[1]["data"]
assert ws_data["status"] == "failed"
assert "Index OOM" in ws_data["error"]
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_error_without_result(self, mock_get_client, mock_emit_ws, mock_api, base_index_kwargs):
"""Falls back to default error message when AsyncResult has no result."""
mock_get_client.return_value = mock_api
mock_async_result = MagicMock()
mock_async_result.result = None
with patch(_PATCH_ASYNC_RESULT, return_value=mock_async_result):
self._call("failed-task-id-2", base_index_kwargs)
mock_emit_ws.assert_called_once()
ws_data = mock_emit_ws.call_args[1]["data"]
assert ws_data["error"] == "Indexing failed"
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_no_doc_id_key_skips_cleanup(self, mock_get_client, mock_emit_ws, mock_api, base_index_kwargs):
"""When doc_id_key is empty, skip remove_document_indexing."""
mock_get_client.return_value = mock_api
base_index_kwargs["doc_id_key"] = ""
mock_async_result = MagicMock()
mock_async_result.result = None
with patch(_PATCH_ASYNC_RESULT, return_value=mock_async_result):
self._call("failed-task-id-3", base_index_kwargs)
mock_api.remove_document_indexing.assert_not_called()
mock_emit_ws.assert_called_once()
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_exception_does_not_crash(self, mock_get_client, mock_emit_ws, mock_api, base_index_kwargs):
"""Exception in callback body is caught and logged, not re-raised."""
mock_get_client.return_value = mock_api
mock_api.remove_document_indexing.side_effect = RuntimeError("oops")
mock_async_result = MagicMock()
mock_async_result.result = None
with patch(_PATCH_ASYNC_RESULT, return_value=mock_async_result):
# Should not raise
self._call("failed-task-id-4", base_index_kwargs)
# ---------------------------------------------------------------------------
# TestIdePromptComplete
# ---------------------------------------------------------------------------
@pytest.mark.usefixtures("no_client_plugins")
class TestIdePromptComplete:
"""Tests for ide_prompt_complete task."""
def _call(self, result_dict, callback_kwargs=None):
from ide_callback.tasks import ide_prompt_complete
return ide_prompt_complete(result_dict, callback_kwargs)
def _make_result(self, output=None, metadata=None):
return {
"success": True,
"data": {
"output": output or {"p1": "answer1"},
"metadata": metadata or {},
},
}
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_success_path(self, mock_get_client, mock_emit_ws, mock_api, base_prompt_kwargs):
mock_get_client.return_value = mock_api
result = self._call(self._make_result(), base_prompt_kwargs)
assert result["status"] == "completed"
assert result["operation"] == "fetch_response"
mock_api.update_prompt_output.assert_called_once_with(
run_id="run-1",
prompt_ids=["p1", "p2"],
outputs={"p1": "answer1"},
document_id="doc-1",
is_single_pass_extract=False,
metadata={},
profile_manager_id="profile-1",
organization_id="org-1",
)
mock_emit_ws.assert_called_once()
ws_data = mock_emit_ws.call_args[1]["data"]
assert ws_data["status"] == "completed"
assert ws_data["operation"] == "fetch_response"
assert ws_data["prompt_ids"] == ["p1", "p2"]
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_executor_failure(self, mock_get_client, mock_emit_ws, mock_api, base_prompt_kwargs, failure_result):
mock_get_client.return_value = mock_api
result = self._call(failure_result, base_prompt_kwargs)
assert result["status"] == "failed"
mock_api.update_prompt_output.assert_not_called()
mock_emit_ws.assert_called_once()
ws_data = mock_emit_ws.call_args[1]["data"]
assert ws_data["status"] == "failed"
assert ws_data["error"] == "Executor blew up"
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_single_pass(self, mock_get_client, mock_emit_ws, mock_api, base_prompt_kwargs):
mock_get_client.return_value = mock_api
base_prompt_kwargs["is_single_pass"] = True
self._call(self._make_result(), base_prompt_kwargs)
call_kwargs = mock_api.update_prompt_output.call_args[1]
assert call_kwargs["is_single_pass_extract"] is True
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_hubspot_event(self, mock_get_client, mock_emit_ws, mock_api, base_prompt_kwargs):
mock_get_client.return_value = mock_api
base_prompt_kwargs["hubspot_user_id"] = "hubspot-42"
base_prompt_kwargs["is_first_prompt_run"] = True
self._call(self._make_result(), base_prompt_kwargs)
mock_api.notify_hubspot.assert_called_once_with(
user_id="hubspot-42",
event_name="PROMPT_RUN",
is_first_for_org=True,
action_label="prompt run",
organization_id="org-1",
)
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_hubspot_failure_non_fatal(self, mock_get_client, mock_emit_ws, mock_api, base_prompt_kwargs):
"""HubSpot notification failure doesn't prevent success."""
mock_get_client.return_value = mock_api
base_prompt_kwargs["hubspot_user_id"] = "hubspot-42"
mock_api.notify_hubspot.side_effect = Exception("HubSpot down")
result = self._call(self._make_result(), base_prompt_kwargs)
assert result["status"] == "completed"
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_elapsed_time_computed(self, mock_get_client, mock_emit_ws, mock_api, base_prompt_kwargs):
"""Elapsed time is computed from dispatch_time when provided."""
mock_get_client.return_value = mock_api
base_prompt_kwargs["dispatch_time"] = time.time() - 5
self._call(self._make_result(), base_prompt_kwargs)
mock_emit_ws.assert_called_once()
ws_data = mock_emit_ws.call_args[1]["data"]
assert ws_data["elapsed"] >= 4 # Allow slight timing variance
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_exception_emits_error_and_reraises(self, mock_get_client, mock_emit_ws, mock_api, base_prompt_kwargs):
mock_get_client.return_value = mock_api
mock_api.update_prompt_output.side_effect = RuntimeError("Network")
with pytest.raises(RuntimeError, match="Network"):
self._call(self._make_result(), base_prompt_kwargs)
# At least one error emission
assert any(
c[1].get("data", {}).get("status") == "failed"
for c in mock_emit_ws.call_args_list
)
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_output_api_failure_omits_result_from_ws(self, mock_get_client, mock_emit_ws, mock_api, base_prompt_kwargs):
"""When update_prompt_output returns success=False, result is not in WS event."""
mock_get_client.return_value = mock_api
mock_api.update_prompt_output.return_value = {"success": False}
result = self._call(self._make_result(), base_prompt_kwargs)
assert result["status"] == "completed"
# result intentionally omitted from WS event — frontend refetches
ws_data = mock_emit_ws.call_args[1]["data"]
assert "result" not in ws_data
# ---------------------------------------------------------------------------
# TestIdePromptError
# ---------------------------------------------------------------------------
class TestIdePromptError:
"""Tests for ide_prompt_error task."""
def _call(self, failed_task_id, callback_kwargs=None):
from ide_callback.tasks import ide_prompt_error
return ide_prompt_error(failed_task_id, callback_kwargs)
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_error_with_result(self, mock_get_client, mock_emit_ws, mock_api, base_prompt_kwargs):
mock_get_client.return_value = mock_api
mock_async_result = MagicMock()
mock_async_result.result = RuntimeError("LLM timeout")
with patch(_PATCH_ASYNC_RESULT, return_value=mock_async_result):
self._call("failed-task-99", base_prompt_kwargs)
mock_emit_ws.assert_called_once()
ws_data = mock_emit_ws.call_args[1]["data"]
assert ws_data["status"] == "failed"
assert "LLM timeout" in ws_data["error"]
assert ws_data["prompt_ids"] == ["p1", "p2"]
assert ws_data["document_id"] == "doc-1"
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_error_without_result(self, mock_get_client, mock_emit_ws, mock_api, base_prompt_kwargs):
mock_get_client.return_value = mock_api
mock_async_result = MagicMock()
mock_async_result.result = None
with patch(_PATCH_ASYNC_RESULT, return_value=mock_async_result):
self._call("failed-task-100", base_prompt_kwargs)
ws_data = mock_emit_ws.call_args[1]["data"]
assert ws_data["error"] == "Prompt execution failed"
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_minimal_callback_kwargs(self, mock_get_client, mock_emit_ws, mock_api):
"""Works with minimal/empty callback_kwargs."""
mock_get_client.return_value = mock_api
mock_async_result = MagicMock()
mock_async_result.result = None
with patch(_PATCH_ASYNC_RESULT, return_value=mock_async_result):
self._call("failed-task-101", {})
mock_emit_ws.assert_called_once()
ws_data = mock_emit_ws.call_args[1]["data"]
assert ws_data["operation"] == "fetch_response"
assert ws_data["prompt_ids"] == []
assert ws_data["document_id"] == ""
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_exception_does_not_crash(self, mock_get_client, mock_emit_ws, mock_api, base_prompt_kwargs):
"""Exception in callback body is caught and logged, not re-raised."""
mock_get_client.return_value = mock_api
mock_emit_ws.side_effect = RuntimeError("ws broken")
mock_async_result = MagicMock()
mock_async_result.result = None
with patch(_PATCH_ASYNC_RESULT, return_value=mock_async_result):
# Should not raise
self._call("failed-task-102", base_prompt_kwargs)
# ---------------------------------------------------------------------------
# TestEmitWebSocket (integration of _emit_websocket helper)
# ---------------------------------------------------------------------------
class TestEmitWebSocket:
"""Test the _emit_websocket helper sends correct payload shape."""
@patch(_PATCH_GET_CLIENT)
def test_websocket_payload_not_double_wrapped(self, mock_get_client, mock_api):
"""Verify Fix 1: data is NOT double-wrapped in {"data": {"data": ...}}."""
mock_get_client.return_value = mock_api
from ide_callback.tasks import _emit_websocket
test_data = {"task_id": "t1", "status": "completed"}
_emit_websocket(mock_api, room="room-1", event="test_event", data=test_data)
mock_api.post.assert_called_once()
payload = mock_api.post.call_args[1]["data"]
assert payload == {
"room": "room-1",
"event": "test_event",
"data": {"task_id": "t1", "status": "completed"},
}
# The payload["data"] should be the raw data, NOT {"data": data}
assert "data" not in payload["data"] or payload["data"] != {"data": test_data}
@patch(_PATCH_GET_CLIENT)
def test_websocket_post_failure_does_not_raise(self, mock_get_client, mock_api):
"""_emit_websocket catches exceptions and logs."""
mock_get_client.return_value = mock_api
mock_api.post.side_effect = RuntimeError("connection refused")
from ide_callback.tasks import _emit_websocket
# Should not raise
_emit_websocket(mock_api, room="room-1", event="test_event", data={})
# ---------------------------------------------------------------------------
# TestJsonSafe
# ---------------------------------------------------------------------------
class TestJsonSafe:
"""Test _json_safe serialization of non-standard types."""
def test_uuid_serialized(self):
import uuid
from ide_callback.tasks import _json_safe
val = {"id": uuid.UUID("12345678-1234-5678-1234-567812345678")}
result = _json_safe(val)
assert result["id"] == "12345678-1234-5678-1234-567812345678"
assert isinstance(result["id"], str)
def test_datetime_serialized(self):
from datetime import datetime
from ide_callback.tasks import _json_safe
val = {"ts": datetime(2024, 1, 15, 12, 0, 0)}
result = _json_safe(val)
assert isinstance(result["ts"], str)
assert "2024-01-15" in result["ts"]
def test_nested_types(self):
import uuid
from datetime import date
from ide_callback.tasks import _json_safe
val = {
"items": [
{"id": uuid.uuid4(), "date": date(2024, 6, 1)},
]
}
result = _json_safe(val)
assert isinstance(result["items"][0]["id"], str)
assert isinstance(result["items"][0]["date"], str)
# ---------------------------------------------------------------------------
# TestTrackSubscriptionUsage (unit tests)
# ---------------------------------------------------------------------------
class TestTrackSubscriptionUsage:
"""Tests for the _track_subscription_usage helper."""
def _call(self, org_id, run_id):
from ide_callback.tasks import _track_subscription_usage
return _track_subscription_usage(org_id, run_id)
def test_skips_when_org_id_empty(self):
"""No-op when org_id is empty."""
with patch(_PATCH_GET_PLUGIN) as mock_gp:
self._call("", "run-1")
mock_gp.assert_not_called()
def test_skips_when_run_id_empty(self):
"""No-op when run_id is empty."""
with patch(_PATCH_GET_PLUGIN) as mock_gp:
self._call("org-1", "")
mock_gp.assert_not_called()
def test_plugin_not_available(self):
"""Gracefully returns when plugin is not installed (OSS mode)."""
with patch(_PATCH_GET_PLUGIN, return_value=None):
self._call("org-1", "run-1") # should not raise
def test_plugin_commits_usage(self):
"""Calls commit_batch_subscription_usage with correct args."""
mock_plugin = MagicMock()
mock_plugin.commit_batch_subscription_usage.return_value = {
"status": "ok",
"committed_count": 1,
}
with patch(_PATCH_GET_PLUGIN, return_value=mock_plugin):
self._call("org-1", "run-42")
mock_plugin.commit_batch_subscription_usage.assert_called_once_with(
organization_id="org-1",
file_execution_ids=["run-42"],
)
def test_plugin_error_non_blocking(self):
"""Exception from plugin is caught; callback continues."""
mock_plugin = MagicMock()
mock_plugin.commit_batch_subscription_usage.side_effect = RuntimeError("boom")
with patch(_PATCH_GET_PLUGIN, return_value=mock_plugin):
self._call("org-1", "run-1") # should not raise
# ---------------------------------------------------------------------------
# TestSubscriptionUsageIntegration (in callback tasks)
# ---------------------------------------------------------------------------
class TestSubscriptionUsageInIndexCallback:
"""Verify _track_subscription_usage is called correctly in ide_index_complete."""
def _call(self, result_dict, callback_kwargs=None):
from ide_callback.tasks import ide_index_complete
return ide_index_complete(result_dict, callback_kwargs)
@patch("ide_callback.tasks._track_subscription_usage")
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_called_on_success(
self, mock_get_client, mock_emit_ws, mock_track, mock_api, base_index_kwargs, success_result
):
mock_get_client.return_value = mock_api
base_index_kwargs["run_id"] = "run-idx-1"
self._call(success_result, base_index_kwargs)
mock_track.assert_called_once_with("org-1", "run-idx-1")
@patch("ide_callback.tasks._track_subscription_usage")
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_not_called_on_executor_failure(
self, mock_get_client, mock_emit_ws, mock_track, mock_api, base_index_kwargs, failure_result
):
mock_get_client.return_value = mock_api
self._call(failure_result, base_index_kwargs)
mock_track.assert_not_called()
class TestSubscriptionUsageInPromptCallback:
"""Verify _track_subscription_usage is called correctly in ide_prompt_complete."""
def _call(self, result_dict, callback_kwargs=None):
from ide_callback.tasks import ide_prompt_complete
return ide_prompt_complete(result_dict, callback_kwargs)
def _make_result(self, output=None):
return {
"success": True,
"data": {"output": output or {"p1": "answer"}, "metadata": {}},
}
@patch("ide_callback.tasks._track_subscription_usage")
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_called_on_success(
self, mock_get_client, mock_emit_ws, mock_track, mock_api, base_prompt_kwargs
):
mock_get_client.return_value = mock_api
self._call(self._make_result(), base_prompt_kwargs)
mock_track.assert_called_once_with("org-1", "run-1")
@patch("ide_callback.tasks._track_subscription_usage")
@patch(_PATCH_EMIT_WS)
@patch(_PATCH_GET_CLIENT)
def test_not_called_on_executor_failure(
self, mock_get_client, mock_emit_ws, mock_track, mock_api, base_prompt_kwargs, failure_result
):
mock_get_client.return_value = mock_api
self._call(failure_result, base_prompt_kwargs)
mock_track.assert_not_called()