LLM-Driven Extraction of Unstructured Data — Built for API Deployments & ETL Pipeline Workflows
Python ai-agentsdata-engineeringdocument-aigenerative-aiidpjson-extractionllmmcp-serverocrpdf-extractionprompt-engineeringstructured-output
"""Full-chain integration tests for LegacyExecutor.
All Phase 2 code and unit tests are complete (2A–2H, 194 workers tests).
This file bridges unit tests and real integration by testing the full
Celery chain:
task.apply() → execute_extraction task → ExecutionOrchestrator
→ ExecutorRegistry.get("legacy") → LegacyExecutor.execute()
→ _handle_X() → ExecutionResult
All in Celery eager mode (no broker needed). External adapters
(X2Text, LLM, VectorDB) are mocked.
"""
import json
from unittest.mock import MagicMock, patch
import pytest
from executor.executors.constants import (
IndexingConstants as IKeys,
)
from executor.executors.constants import (
PromptServiceConstants as PSKeys,
)
from unstract.sdk1.execution.context import ExecutionContext, Operation
from unstract.sdk1.execution.registry import ExecutorRegistry
from unstract.sdk1.execution.result import ExecutionResult
# ---------------------------------------------------------------------------
# Patch targets
# ---------------------------------------------------------------------------
_PATCH_X2TEXT = "executor.executors.legacy_executor.X2Text"
_PATCH_FS = "executor.executors.legacy_executor.FileUtils.get_fs_instance"
_PATCH_INDEX_DEPS = "executor.executors.legacy_executor.LegacyExecutor._get_indexing_deps"
_PATCH_PROMPT_DEPS = "executor.executors.legacy_executor.LegacyExecutor._get_prompt_deps"
_PATCH_SHIM = "executor.executors.legacy_executor.ExecutorToolShim"
_PATCH_RUN_COMPLETION = (
"executor.executors.answer_prompt.AnswerPromptService.run_completion"
)
_PATCH_INDEX_UTILS = "unstract.sdk1.utils.indexing.IndexingUtils.generate_index_key"
# ---------------------------------------------------------------------------
# Fixtures
# ---------------------------------------------------------------------------
@pytest.fixture(autouse=True)
def _ensure_legacy_registered():
"""Ensure LegacyExecutor is registered without clearing other state.
Unlike unit tests that clear() + re-register, sanity tests need
LegacyExecutor always present. We add it idempotently.
"""
from executor.executors.legacy_executor import LegacyExecutor
if "legacy" not in ExecutorRegistry.list_executors():
ExecutorRegistry._registry["legacy"] = LegacyExecutor
yield
@pytest.fixture
def eager_app():
"""Configure the real executor Celery app for eager-mode testing."""
from executor.worker import app
original = {
"task_always_eager": app.conf.task_always_eager,
"task_eager_propagates": app.conf.task_eager_propagates,
"result_backend": app.conf.result_backend,
}
app.conf.update(
task_always_eager=True,
task_eager_propagates=False,
result_backend="cache+memory://",
)
yield app
app.conf.update(original)
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
def _run_task(eager_app, ctx_dict):
"""Run execute_extraction task via task.apply() (eager-safe)."""
task = eager_app.tasks["execute_extraction"]
result = task.apply(args=[ctx_dict])
return result.get()
def _mock_llm(answer="sanity answer"):
"""Create a mock LLM matching the test_answer_prompt.py pattern."""
llm = MagicMock(name="llm")
response = MagicMock()
response.text = answer
llm.complete.return_value = {
PSKeys.RESPONSE: response,
PSKeys.HIGHLIGHT_DATA: [],
PSKeys.CONFIDENCE_DATA: None,
PSKeys.WORD_CONFIDENCE_DATA: None,
PSKeys.LINE_NUMBERS: [],
PSKeys.WHISPER_HASH: "",
}
llm.get_usage_reason.return_value = "extraction"
llm.get_metrics.return_value = {"tokens": 100}
return llm
def _mock_prompt_deps(llm=None):
"""Return a 7-tuple matching _get_prompt_deps() return shape.
Uses the real AnswerPromptService + mocked adapters.
"""
if llm is None:
llm = _mock_llm()
from executor.executors.answer_prompt import (
AnswerPromptService as answer_prompt_svc_cls,
)
retrieval_svc = MagicMock(name="RetrievalService")
retrieval_svc.run_retrieval.return_value = ["chunk1", "chunk2"]
retrieval_svc.retrieve_complete_context.return_value = ["full content"]
variable_replacement_svc = MagicMock(name="VariableReplacementService")
variable_replacement_svc.is_variables_present.return_value = False
index_cls = MagicMock(name="Index")
index_instance = MagicMock()
index_instance.generate_index_key.return_value = "doc-id-sanity"
index_cls.return_value = index_instance
llm_cls = MagicMock(name="LLM")
llm_cls.return_value = llm
embedding_compat_cls = MagicMock(name="EmbeddingCompat")
vector_db_cls = MagicMock(name="VectorDB")
return (
answer_prompt_svc_cls,
retrieval_svc,
variable_replacement_svc,
index_cls,
llm_cls,
embedding_compat_cls,
vector_db_cls,
)
def _mock_process_response(text="sanity extracted text"):
"""Build a mock TextExtractionResult."""
from unstract.sdk1.adapters.x2text.dto import (
TextExtractionMetadata,
TextExtractionResult,
)
metadata = TextExtractionMetadata(whisper_hash="sanity-hash")
return TextExtractionResult(
extracted_text=text,
extraction_metadata=metadata,
)
def _make_prompt(
name="field_a", prompt="What is the revenue?", output_type="text", **overrides
):
"""Build a minimal prompt definition dict."""
d = {
PSKeys.NAME: name,
PSKeys.PROMPT: prompt,
PSKeys.TYPE: output_type,
PSKeys.CHUNK_SIZE: 512,
PSKeys.CHUNK_OVERLAP: 128,
PSKeys.RETRIEVAL_STRATEGY: "simple",
PSKeys.LLM: "llm-1",
PSKeys.EMBEDDING: "emb-1",
PSKeys.VECTOR_DB: "vdb-1",
PSKeys.X2TEXT_ADAPTER: "x2t-1",
PSKeys.SIMILARITY_TOP_K: 5,
}
d.update(overrides)
return d
# --- Context factories per operation ---
def _extract_ctx(**overrides):
defaults = {
"executor_name": "legacy",
"operation": "extract",
"run_id": "run-sanity-ext",
"execution_source": "tool",
"organization_id": "org-test",
"executor_params": {
"x2text_instance_id": "x2t-sanity",
"file_path": "/data/sanity.pdf",
"platform_api_key": "sk-sanity",
},
}
defaults.update(overrides)
return ExecutionContext(**defaults)
def _index_ctx(**overrides):
defaults = {
"executor_name": "legacy",
"operation": "index",
"run_id": "run-sanity-idx",
"execution_source": "tool",
"organization_id": "org-test",
"executor_params": {
"embedding_instance_id": "emb-sanity",
"vector_db_instance_id": "vdb-sanity",
"x2text_instance_id": "x2t-sanity",
"file_path": "/data/sanity.pdf",
"file_hash": "sanity-hash",
"extracted_text": "Sanity test document text",
"platform_api_key": "sk-sanity",
"chunk_size": 512,
"chunk_overlap": 128,
},
}
defaults.update(overrides)
return ExecutionContext(**defaults)
def _answer_prompt_ctx(prompts=None, **overrides):
if prompts is None:
prompts = [_make_prompt()]
defaults = {
"executor_name": "legacy",
"operation": Operation.ANSWER_PROMPT.value,
"run_id": "run-sanity-ap",
"execution_source": "ide",
"executor_params": {
PSKeys.OUTPUTS: prompts,
PSKeys.TOOL_SETTINGS: {},
PSKeys.TOOL_ID: "tool-sanity",
PSKeys.EXECUTION_ID: "exec-sanity",
PSKeys.FILE_HASH: "hash-sanity",
PSKeys.FILE_PATH: "/data/sanity.txt",
PSKeys.FILE_NAME: "sanity.txt",
PSKeys.LOG_EVENTS_ID: "",
PSKeys.CUSTOM_DATA: {},
PSKeys.EXECUTION_SOURCE: "ide",
PSKeys.PLATFORM_SERVICE_API_KEY: "pk-sanity",
},
}
defaults.update(overrides)
return ExecutionContext(**defaults)
def _summarize_ctx(**overrides):
defaults = {
"executor_name": "legacy",
"operation": "summarize",
"run_id": "run-sanity-sum",
"execution_source": "tool",
"executor_params": {
"llm_adapter_instance_id": "llm-sanity",
"summarize_prompt": "Summarize the document.",
"context": "Long document content here.",
"prompt_keys": ["invoice_number", "total"],
"PLATFORM_SERVICE_API_KEY": "pk-sanity",
},
}
defaults.update(overrides)
return ExecutionContext(**defaults)
# ===========================================================================
# Test classes
# ===========================================================================
class TestSanityExtract:
"""Full-chain extract tests through Celery eager mode."""
@patch(_PATCH_FS)
@patch(_PATCH_X2TEXT)
def test_extract_full_chain(self, mock_x2text_cls, mock_get_fs, eager_app):
"""Mocked X2Text + FileUtils → result.data has extracted_text."""
mock_x2text = MagicMock()
mock_x2text.process.return_value = _mock_process_response("sanity extracted")
mock_x2text.x2text_instance = MagicMock()
mock_x2text_cls.return_value = mock_x2text
mock_get_fs.return_value = MagicMock()
ctx = _extract_ctx()
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is True
assert result.data[IKeys.EXTRACTED_TEXT] == "sanity extracted"
@patch(_PATCH_FS)
@patch(_PATCH_X2TEXT)
def test_extract_missing_params_full_chain(
self, mock_x2text_cls, mock_get_fs, eager_app
):
"""Empty params → failure with missing fields message."""
ctx = _extract_ctx(executor_params={"platform_api_key": "sk-test"})
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is False
assert "x2text_instance_id" in result.error
assert "file_path" in result.error
@patch(_PATCH_FS)
@patch(_PATCH_X2TEXT)
def test_extract_adapter_error_full_chain(
self, mock_x2text_cls, mock_get_fs, eager_app
):
"""X2Text raises AdapterError → failure result, no unhandled exception."""
from unstract.sdk1.adapters.exceptions import AdapterError
mock_x2text = MagicMock()
mock_x2text.x2text_instance = MagicMock()
mock_x2text.x2text_instance.get_name.return_value = "SanityExtractor"
mock_x2text.process.side_effect = AdapterError("sanity adapter err")
mock_x2text_cls.return_value = mock_x2text
mock_get_fs.return_value = MagicMock()
ctx = _extract_ctx()
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is False
assert "SanityExtractor" in result.error
assert "sanity adapter err" in result.error
class TestSanityIndex:
"""Full-chain index tests through Celery eager mode."""
@patch(_PATCH_FS)
@patch(_PATCH_INDEX_DEPS)
def test_index_full_chain(self, mock_deps, mock_get_fs, eager_app):
"""Mocked _get_indexing_deps → result.data has doc_id."""
mock_index_cls = MagicMock()
mock_index = MagicMock()
mock_index.generate_index_key.return_value = "doc-sanity-idx"
mock_index.is_document_indexed.return_value = False
mock_index.perform_indexing.return_value = "doc-sanity-idx"
mock_index_cls.return_value = mock_index
mock_emb_cls = MagicMock()
mock_emb_cls.return_value = MagicMock()
mock_vdb_cls = MagicMock()
mock_vdb_cls.return_value = MagicMock()
mock_deps.return_value = (mock_index_cls, mock_emb_cls, mock_vdb_cls)
mock_get_fs.return_value = MagicMock()
ctx = _index_ctx()
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is True
assert result.data[IKeys.DOC_ID] == "doc-sanity-idx"
@patch(_PATCH_INDEX_UTILS, return_value="doc-zero-chunk-sanity")
@patch(_PATCH_FS)
def test_index_chunk_size_zero_full_chain(self, mock_get_fs, mock_gen_key, eager_app):
"""chunk_size=0 skips heavy deps → returns doc_id via IndexingUtils."""
mock_get_fs.return_value = MagicMock()
params = {
"embedding_instance_id": "emb-sanity",
"vector_db_instance_id": "vdb-sanity",
"x2text_instance_id": "x2t-sanity",
"file_path": "/data/sanity.pdf",
"file_hash": "sanity-hash",
"extracted_text": "text",
"platform_api_key": "sk-sanity",
"chunk_size": 0,
"chunk_overlap": 0,
}
ctx = _index_ctx(executor_params=params)
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is True
assert result.data[IKeys.DOC_ID] == "doc-zero-chunk-sanity"
@patch(_PATCH_FS)
@patch(_PATCH_INDEX_DEPS)
def test_index_error_full_chain(self, mock_deps, mock_get_fs, eager_app):
"""perform_indexing raises → failure result."""
mock_index_cls = MagicMock()
mock_index = MagicMock()
mock_index.generate_index_key.return_value = "doc-err"
mock_index.is_document_indexed.return_value = False
mock_index.perform_indexing.side_effect = RuntimeError("VDB down")
mock_index_cls.return_value = mock_index
mock_emb_cls = MagicMock()
mock_emb_cls.return_value = MagicMock()
mock_vdb_cls = MagicMock()
mock_vdb_cls.return_value = MagicMock()
mock_deps.return_value = (mock_index_cls, mock_emb_cls, mock_vdb_cls)
mock_get_fs.return_value = MagicMock()
ctx = _index_ctx()
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is False
assert "indexing" in result.error.lower()
class TestSanityAnswerPrompt:
"""Full-chain answer_prompt tests through Celery eager mode."""
@patch(_PATCH_INDEX_UTILS, return_value="doc-id-sanity")
@patch(_PATCH_PROMPT_DEPS)
@patch(_PATCH_SHIM)
def test_answer_prompt_text_full_chain(
self, mock_shim_cls, mock_deps, _mock_idx, eager_app
):
"""TEXT prompt → result.data has output, metadata, metrics."""
llm = _mock_llm("sanity answer")
mock_deps.return_value = _mock_prompt_deps(llm)
mock_shim_cls.return_value = MagicMock()
ctx = _answer_prompt_ctx()
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is True
assert PSKeys.OUTPUT in result.data
assert PSKeys.METADATA in result.data
assert PSKeys.METRICS in result.data
assert result.data[PSKeys.OUTPUT]["field_a"] == "sanity answer"
@patch(_PATCH_INDEX_UTILS, return_value="doc-id-sanity")
@patch(_PATCH_PROMPT_DEPS)
@patch(_PATCH_SHIM)
def test_answer_prompt_multi_prompt_full_chain(
self, mock_shim_cls, mock_deps, _mock_idx, eager_app
):
"""Two prompts → both field names in output and metrics."""
llm = _mock_llm("multi answer")
mock_deps.return_value = _mock_prompt_deps(llm)
mock_shim_cls.return_value = MagicMock()
prompts = [
_make_prompt(name="revenue"),
_make_prompt(name="date_signed"),
]
ctx = _answer_prompt_ctx(prompts=prompts)
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is True
assert "revenue" in result.data[PSKeys.OUTPUT]
assert "date_signed" in result.data[PSKeys.OUTPUT]
assert "revenue" in result.data[PSKeys.METRICS]
assert "date_signed" in result.data[PSKeys.METRICS]
@patch(_PATCH_INDEX_UTILS, return_value="doc-id-sanity")
@patch(_PATCH_PROMPT_DEPS)
@patch(_PATCH_SHIM)
def test_answer_prompt_table_fails_full_chain(
self, mock_shim_cls, mock_deps, _mock_idx, eager_app
):
"""TABLE type → failure mentioning TABLE."""
llm = _mock_llm()
mock_deps.return_value = _mock_prompt_deps(llm)
mock_shim_cls.return_value = MagicMock()
ctx = _answer_prompt_ctx(prompts=[_make_prompt(output_type="table")])
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is False
assert "TABLE" in result.error
class TestSanitySinglePass:
"""Full-chain single_pass_extraction test."""
@patch(_PATCH_INDEX_UTILS, return_value="doc-id-sanity")
@patch(_PATCH_PROMPT_DEPS)
@patch(_PATCH_SHIM)
def test_single_pass_delegates_full_chain(
self, mock_shim_cls, mock_deps, _mock_idx, eager_app
):
"""Same mocks as answer_prompt → same response shape."""
llm = _mock_llm("single pass answer")
mock_deps.return_value = _mock_prompt_deps(llm)
mock_shim_cls.return_value = MagicMock()
ctx = _answer_prompt_ctx(
operation=Operation.SINGLE_PASS_EXTRACTION.value,
)
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is True
assert PSKeys.OUTPUT in result.data
assert result.data[PSKeys.OUTPUT]["field_a"] == "single pass answer"
class TestSanitySummarize:
"""Full-chain summarize tests through Celery eager mode."""
@patch(_PATCH_RUN_COMPLETION, return_value="Sanity summary text.")
@patch(_PATCH_PROMPT_DEPS)
@patch(_PATCH_SHIM)
def test_summarize_full_chain(
self, mock_shim_cls, mock_get_deps, mock_run, eager_app
):
"""Mocked _get_prompt_deps + run_completion → result.data has summary."""
mock_llm_cls = MagicMock()
mock_llm_cls.return_value = MagicMock()
mock_get_deps.return_value = (
MagicMock(),
MagicMock(),
MagicMock(),
MagicMock(),
mock_llm_cls,
MagicMock(),
MagicMock(),
)
ctx = _summarize_ctx()
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is True
assert result.data["data"] == "Sanity summary text."
def test_summarize_missing_llm_full_chain(self, eager_app):
"""Missing llm_adapter_instance_id → failure."""
ctx = _summarize_ctx(
executor_params={
"llm_adapter_instance_id": "",
"summarize_prompt": "Summarize.",
"context": "Document text.",
"PLATFORM_SERVICE_API_KEY": "pk-test",
}
)
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is False
assert "llm_adapter_instance_id" in result.error
@patch(_PATCH_RUN_COMPLETION, side_effect=Exception("LLM down"))
@patch(_PATCH_PROMPT_DEPS)
@patch(_PATCH_SHIM)
def test_summarize_error_full_chain(
self, mock_shim_cls, mock_get_deps, mock_run, eager_app
):
"""run_completion raises → failure mentioning summarization."""
mock_llm_cls = MagicMock()
mock_llm_cls.return_value = MagicMock()
mock_get_deps.return_value = (
MagicMock(),
MagicMock(),
MagicMock(),
MagicMock(),
mock_llm_cls,
MagicMock(),
MagicMock(),
)
ctx = _summarize_ctx()
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is False
assert "summarization" in result.error.lower() or "LLM" in result.error
class TestSanityAgenticExtraction:
"""Full-chain agentic operations test — rejected by LegacyExecutor."""
def test_agentic_extract_rejected_by_legacy(self, eager_app):
"""Agentic operations are handled by cloud executor, not legacy."""
ctx = ExecutionContext(
executor_name="legacy",
operation="agentic_extract",
run_id="run-sanity-agentic",
execution_source="tool",
)
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is False
assert "does not support" in result.error
class TestSanityResponseContracts:
"""Verify response dicts survive JSON round-trip with expected keys."""
@patch(_PATCH_FS)
@patch(_PATCH_X2TEXT)
def test_extract_contract(self, mock_x2text_cls, mock_get_fs, eager_app):
mock_x2text = MagicMock()
mock_x2text.process.return_value = _mock_process_response("contract")
mock_x2text.x2text_instance = MagicMock()
mock_x2text_cls.return_value = mock_x2text
mock_get_fs.return_value = MagicMock()
ctx = _extract_ctx()
result_dict = _run_task(eager_app, ctx.to_dict())
# JSON round-trip
serialized = json.dumps(result_dict)
deserialized = json.loads(serialized)
result = ExecutionResult.from_dict(deserialized)
assert result.success is True
assert isinstance(result.data[IKeys.EXTRACTED_TEXT], str)
@patch(_PATCH_FS)
@patch(_PATCH_INDEX_DEPS)
def test_index_contract(self, mock_deps, mock_get_fs, eager_app):
mock_index_cls = MagicMock()
mock_index = MagicMock()
mock_index.generate_index_key.return_value = "doc-contract"
mock_index.is_document_indexed.return_value = False
mock_index.perform_indexing.return_value = "doc-contract"
mock_index_cls.return_value = mock_index
mock_emb_cls = MagicMock()
mock_emb = MagicMock()
mock_emb.flush_pending_usage.return_value = [] # must be JSON-serializable
mock_emb_cls.return_value = mock_emb
mock_vdb_cls = MagicMock()
mock_vdb_cls.return_value = MagicMock()
mock_deps.return_value = (mock_index_cls, mock_emb_cls, mock_vdb_cls)
mock_get_fs.return_value = MagicMock()
ctx = _index_ctx()
result_dict = _run_task(eager_app, ctx.to_dict())
serialized = json.dumps(result_dict)
deserialized = json.loads(serialized)
result = ExecutionResult.from_dict(deserialized)
assert result.success is True
assert isinstance(result.data[IKeys.DOC_ID], str)
@patch(_PATCH_INDEX_UTILS, return_value="doc-id-sanity")
@patch(_PATCH_PROMPT_DEPS)
@patch(_PATCH_SHIM)
def test_answer_prompt_contract(self, mock_shim_cls, mock_deps, _mock_idx, eager_app):
llm = _mock_llm("contract answer")
mock_deps.return_value = _mock_prompt_deps(llm)
mock_shim_cls.return_value = MagicMock()
ctx = _answer_prompt_ctx()
result_dict = _run_task(eager_app, ctx.to_dict())
serialized = json.dumps(result_dict)
deserialized = json.loads(serialized)
result = ExecutionResult.from_dict(deserialized)
assert result.success is True
assert isinstance(result.data[PSKeys.OUTPUT], dict)
assert isinstance(result.data[PSKeys.METADATA], dict)
assert isinstance(result.data[PSKeys.METRICS], dict)
@patch(_PATCH_RUN_COMPLETION, return_value="contract summary")
@patch(_PATCH_PROMPT_DEPS)
@patch(_PATCH_SHIM)
def test_summarize_contract(self, mock_shim_cls, mock_get_deps, mock_run, eager_app):
mock_llm_cls = MagicMock()
mock_llm_cls.return_value = MagicMock()
mock_get_deps.return_value = (
MagicMock(),
MagicMock(),
MagicMock(),
MagicMock(),
mock_llm_cls,
MagicMock(),
MagicMock(),
)
ctx = _summarize_ctx()
result_dict = _run_task(eager_app, ctx.to_dict())
serialized = json.dumps(result_dict)
deserialized = json.loads(serialized)
result = ExecutionResult.from_dict(deserialized)
assert result.success is True
assert isinstance(result.data["data"], str)
class TestSanityDispatcher:
"""Full-chain dispatcher tests, running the executor task in-process."""
@patch(_PATCH_FS)
@patch(_PATCH_X2TEXT)
def test_dispatcher_dispatch_full_chain(
self, mock_x2text_cls, mock_get_fs, eager_app
):
"""The dispatcher drives the executor task and returns its result.
``EagerExecutorTransport`` runs ``execute_extraction`` in-process rather
than enqueueing it, so this still exercises the full
dispatcher → task → orchestrator chain without a queue or a database.
"""
from unstract.workflow_execution.executor_rpc import PgExecutionDispatcher
from .executor_dispatch_fakes import EagerExecutorTransport
mock_x2text = MagicMock()
mock_x2text.process.return_value = _mock_process_response("dispatched")
mock_x2text.x2text_instance = MagicMock()
mock_x2text_cls.return_value = mock_x2text
mock_get_fs.return_value = MagicMock()
transport = EagerExecutorTransport(eager_app.tasks["execute_extraction"])
dispatcher = PgExecutionDispatcher(transport)
result = dispatcher.dispatch(_extract_ctx(), timeout=10)
assert isinstance(result, ExecutionResult)
assert result.success is True
assert result.data[IKeys.EXTRACTED_TEXT] == "dispatched"
assert transport.queue == "celery_executor_legacy"
# ``test_dispatcher_no_app_raises`` is gone with the Celery dispatcher it
# characterised: ``PgExecutionDispatcher`` is transport-injected and never
# raises by contract — an enqueue failure becomes ``ExecutionResult.failure``.
# That contract is covered in ``test_executor_rpc.py``, which drives a
# transport whose ``enqueue`` raises; duplicating it here would assert the
# shared dispatcher's behaviour a second time in a suite about the pipeline.
class TestSanityCrossCutting:
"""Cross-cutting concerns: unknown ops, invalid contexts, error round-trip."""
def test_unknown_operation_full_chain(self, eager_app):
"""operation='nonexistent' → failure mentioning unsupported."""
ctx = ExecutionContext(
executor_name="legacy",
operation="nonexistent",
run_id="run-sanity-unknown",
execution_source="tool",
)
result_dict = _run_task(eager_app, ctx.to_dict())
result = ExecutionResult.from_dict(result_dict)
assert result.success is False
assert "nonexistent" in result.error.lower()
def test_invalid_context_dict_full_chain(self, eager_app):
"""Malformed dict → failure mentioning 'Invalid execution context'."""
result_dict = _run_task(eager_app, {"bad": "data"})
result = ExecutionResult.from_dict(result_dict)
assert result.success is False
assert "Invalid execution context" in result.error
@patch(_PATCH_FS)
@patch(_PATCH_X2TEXT)
def test_failure_result_json_round_trip(
self, mock_x2text_cls, mock_get_fs, eager_app
):
"""Failure result survives JSON serialization with error preserved."""
from unstract.sdk1.adapters.exceptions import AdapterError
mock_x2text = MagicMock()
mock_x2text.x2text_instance = MagicMock()
mock_x2text.x2text_instance.get_name.return_value = "FailExtractor"
mock_x2text.process.side_effect = AdapterError("round trip error")
mock_x2text_cls.return_value = mock_x2text
mock_get_fs.return_value = MagicMock()
ctx = _extract_ctx()
result_dict = _run_task(eager_app, ctx.to_dict())
# Verify raw dict survives JSON round-trip
serialized = json.dumps(result_dict)
deserialized = json.loads(serialized)
result = ExecutionResult.from_dict(deserialized)
assert result.success is False
assert "round trip error" in result.error
assert "FailExtractor" in result.error