LLM-Driven Extraction of Unstructured Data — Built for API Deployments & ETL Pipeline Workflows
Python ai-agentsdata-engineeringdocument-aigenerative-aiidpjson-extractionllmmcp-serverocrpdf-extractionprompt-engineeringstructured-output
"""Phase 2C — LegacyExecutor._handle_index tests.
Verifies:
1. Happy path: indexing returns success with doc_id
2. Chunk size 0: skips indexing, still returns doc_id
3. Missing required params → failure result
4. Reindex flag: passes reindex through to Index
5. VectorDB.close() always called (even on error)
6. Indexing error → LegacyExecutorError → failure result
7. Orchestrator integration: index returns success (mocked)
8. Celery eager-mode: full task chain returns indexing result
9. Index class: generate_index_key called with correct DTOs
10. EmbeddingCompat and VectorDB created with correct params
Heavy SDK1 dependencies (llama_index, qdrant) are lazily imported
via ``LegacyExecutor._get_indexing_deps()``. We mock that method
to avoid protobuf conflicts in the test environment.
"""
from unittest.mock import MagicMock, patch
import pytest
from executor.executors.constants import IndexingConstants as IKeys
from unstract.sdk1.execution.context import ExecutionContext
from unstract.sdk1.execution.orchestrator import ExecutionOrchestrator
from unstract.sdk1.execution.registry import ExecutorRegistry
from unstract.sdk1.execution.result import ExecutionResult
@pytest.fixture(autouse=True)
def _clean_registry():
ExecutorRegistry.clear()
yield
ExecutorRegistry.clear()
def _register_legacy():
# Guarded because the import below may be the FIRST in the process, in which
# case ``@ExecutorRegistry.register`` fires on it and registering again
# raises a duplicate-name ValueError.
from executor.executors.legacy_executor import LegacyExecutor
if "legacy" not in ExecutorRegistry.list_executors():
ExecutorRegistry.register(LegacyExecutor)
def _make_index_context(**overrides):
defaults = {
"executor_name": "legacy",
"operation": "index",
"run_id": "run-2c-001",
"execution_source": "tool",
"organization_id": "org-test",
"request_id": "req-2c-001",
"executor_params": {
"embedding_instance_id": "emb-001",
"vector_db_instance_id": "vdb-001",
"x2text_instance_id": "x2t-001",
"file_path": "/data/test.pdf",
"file_hash": "abc123",
"extracted_text": "Hello world",
"platform_api_key": "sk-test",
"chunk_size": 512,
"chunk_overlap": 128,
},
}
defaults.update(overrides)
return ExecutionContext(**defaults)
_PATCH_FS = "executor.executors.legacy_executor.FileUtils.get_fs_instance"
_PATCH_DEPS = (
"executor.executors.legacy_executor.LegacyExecutor._get_indexing_deps"
)
@pytest.fixture
def mock_indexing_deps():
"""Mock the heavy indexing dependencies via _get_indexing_deps()."""
mock_index_cls = MagicMock()
mock_emb_cls = MagicMock()
mock_vdb_cls = MagicMock()
with patch(_PATCH_DEPS, return_value=(mock_index_cls, mock_emb_cls, mock_vdb_cls)):
yield mock_index_cls, mock_emb_cls, mock_vdb_cls
def _setup_mock_index(mock_index_cls, doc_id="doc-hash-123"):
"""Configure a mock Index instance."""
mock_index = MagicMock()
mock_index.generate_index_key.return_value = doc_id
mock_index.is_document_indexed.return_value = False
mock_index.perform_indexing.return_value = doc_id
mock_index_cls.return_value = mock_index
return mock_index
# --- 1. Happy path ---
class TestHappyPath:
@patch(_PATCH_FS)
def test_index_returns_success_with_doc_id(
self, mock_get_fs, mock_indexing_deps
):
mock_index_cls, mock_emb_cls, mock_vdb_cls = mock_indexing_deps
_register_legacy()
executor = ExecutorRegistry.get("legacy")
_setup_mock_index(mock_index_cls, "doc-hash-123")
mock_emb_cls.return_value = MagicMock()
mock_vdb = MagicMock()
mock_vdb_cls.return_value = mock_vdb
mock_get_fs.return_value = MagicMock()
ctx = _make_index_context()
result = executor.execute(ctx)
assert result.success is True
assert result.data[IKeys.DOC_ID] == "doc-hash-123"
mock_vdb.close.assert_called_once()
# --- 2. Chunk size 0: skips indexing ---
class TestChunkSizeZero:
@patch(
"unstract.sdk1.utils.indexing.IndexingUtils.generate_index_key",
return_value="doc-zero-chunk",
)
@patch(_PATCH_FS)
def test_chunk_size_zero_skips_indexing(self, mock_get_fs, mock_gen_key):
_register_legacy()
executor = ExecutorRegistry.get("legacy")
mock_get_fs.return_value = MagicMock()
ctx = _make_index_context(
executor_params={
"embedding_instance_id": "emb-001",
"vector_db_instance_id": "vdb-001",
"x2text_instance_id": "x2t-001",
"file_path": "/data/test.pdf",
"file_hash": "abc123",
"extracted_text": "text",
"platform_api_key": "sk-test",
"chunk_size": 0,
"chunk_overlap": 0,
}
)
result = executor.execute(ctx)
assert result.success is True
assert result.data[IKeys.DOC_ID] == "doc-zero-chunk"
mock_gen_key.assert_called_once()
# --- 3. Missing required params ---
class TestMissingParams:
def test_missing_embedding_instance_id(self):
_register_legacy()
executor = ExecutorRegistry.get("legacy")
ctx = _make_index_context(
executor_params={
"vector_db_instance_id": "vdb-001",
"x2text_instance_id": "x2t-001",
"file_path": "/data/test.pdf",
"platform_api_key": "sk-test",
}
)
result = executor.execute(ctx)
assert result.success is False
assert "embedding_instance_id" in result.error
def test_missing_multiple_params(self):
_register_legacy()
executor = ExecutorRegistry.get("legacy")
ctx = _make_index_context(
executor_params={"platform_api_key": "sk-test"}
)
result = executor.execute(ctx)
assert result.success is False
assert "embedding_instance_id" in result.error
assert "vector_db_instance_id" in result.error
assert "x2text_instance_id" in result.error
assert "file_path" in result.error
# --- 4. Reindex flag ---
class TestReindex:
@patch(_PATCH_FS)
def test_reindex_passed_through(self, mock_get_fs, mock_indexing_deps):
mock_index_cls, mock_emb_cls, mock_vdb_cls = mock_indexing_deps
_register_legacy()
executor = ExecutorRegistry.get("legacy")
_setup_mock_index(mock_index_cls, "doc-reindex")
mock_index_cls.return_value.is_document_indexed.return_value = True
mock_emb_cls.return_value = MagicMock()
mock_vdb_cls.return_value = MagicMock()
mock_get_fs.return_value = MagicMock()
ctx = _make_index_context(
executor_params={
"embedding_instance_id": "emb-001",
"vector_db_instance_id": "vdb-001",
"x2text_instance_id": "x2t-001",
"file_path": "/data/test.pdf",
"file_hash": "abc123",
"extracted_text": "text",
"platform_api_key": "sk-test",
"chunk_size": 512,
"chunk_overlap": 128,
"reindex": True,
}
)
result = executor.execute(ctx)
assert result.success is True
init_call = mock_index_cls.call_args
assert init_call.kwargs["processing_options"].reindex is True
# reindex=True with already-indexed doc must still call perform_indexing
mock_index_cls.return_value.perform_indexing.assert_called_once()
@patch(_PATCH_FS)
def test_already_indexed_no_reindex_short_circuits(
self, mock_get_fs, mock_indexing_deps
):
"""doc_id already in VDB and reindex=False → skip perform_indexing.
This is the defense-in-depth guard introduced for the IDE
re-indexing fix: even if the Redis cache misses and Answer Prompt
re-dispatches index, the executor must not re-write the same chunks
into the vector store.
"""
mock_index_cls, mock_emb_cls, mock_vdb_cls = mock_indexing_deps
_register_legacy()
executor = ExecutorRegistry.get("legacy")
mock_index = _setup_mock_index(mock_index_cls, "doc-already-indexed")
mock_index.is_document_indexed.return_value = True
mock_emb_cls.return_value = MagicMock()
mock_vdb_cls.return_value = MagicMock()
mock_get_fs.return_value = MagicMock()
# reindex defaults to False
ctx = _make_index_context()
result = executor.execute(ctx)
assert result.success is True
assert result.data[IKeys.DOC_ID] == "doc-already-indexed"
mock_index.is_document_indexed.assert_called_once()
mock_index.perform_indexing.assert_not_called()
# --- 5. VectorDB.close() always called ---
class TestVectorDBClose:
@patch(_PATCH_FS)
def test_vectordb_closed_on_success(self, mock_get_fs, mock_indexing_deps):
mock_index_cls, mock_emb_cls, mock_vdb_cls = mock_indexing_deps
_register_legacy()
executor = ExecutorRegistry.get("legacy")
_setup_mock_index(mock_index_cls)
mock_emb_cls.return_value = MagicMock()
mock_vdb = MagicMock()
mock_vdb_cls.return_value = mock_vdb
mock_get_fs.return_value = MagicMock()
ctx = _make_index_context()
executor.execute(ctx)
mock_vdb.close.assert_called_once()
@patch(_PATCH_FS)
def test_vectordb_closed_on_error(self, mock_get_fs, mock_indexing_deps):
mock_index_cls, mock_emb_cls, mock_vdb_cls = mock_indexing_deps
_register_legacy()
executor = ExecutorRegistry.get("legacy")
mock_index = _setup_mock_index(mock_index_cls)
mock_index.is_document_indexed.side_effect = RuntimeError("boom")
mock_emb_cls.return_value = MagicMock()
mock_vdb = MagicMock()
mock_vdb_cls.return_value = mock_vdb
mock_get_fs.return_value = MagicMock()
ctx = _make_index_context()
result = executor.execute(ctx)
assert result.success is False
mock_vdb.close.assert_called_once()
# --- 6. Indexing error → failure result ---
class TestIndexingError:
@patch(_PATCH_FS)
def test_indexing_error_returns_failure(
self, mock_get_fs, mock_indexing_deps
):
mock_index_cls, mock_emb_cls, mock_vdb_cls = mock_indexing_deps
_register_legacy()
executor = ExecutorRegistry.get("legacy")
mock_index = _setup_mock_index(mock_index_cls, "doc-err")
mock_index.perform_indexing.side_effect = RuntimeError(
"vector DB unavailable"
)
mock_emb_cls.return_value = MagicMock()
mock_vdb_cls.return_value = MagicMock()
mock_get_fs.return_value = MagicMock()
ctx = _make_index_context()
result = executor.execute(ctx)
assert result.success is False
assert "indexing" in result.error.lower()
assert "vector DB unavailable" in result.error
# --- 7. Orchestrator integration ---
class TestOrchestratorIntegration:
@patch(_PATCH_FS)
def test_orchestrator_index_returns_success(
self, mock_get_fs, mock_indexing_deps
):
mock_index_cls, mock_emb_cls, mock_vdb_cls = mock_indexing_deps
_register_legacy()
orchestrator = ExecutionOrchestrator()
_setup_mock_index(mock_index_cls, "doc-orch")
mock_emb_cls.return_value = MagicMock()
mock_vdb_cls.return_value = MagicMock()
mock_get_fs.return_value = MagicMock()
ctx = _make_index_context()
result = orchestrator.execute(ctx)
assert result.success is True
assert result.data[IKeys.DOC_ID] == "doc-orch"
# --- 8. Celery eager-mode ---
@pytest.fixture
def eager_app():
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)
class TestCeleryEager:
@patch(_PATCH_FS)
def test_eager_index_returns_success(
self, mock_get_fs, mock_indexing_deps, eager_app
):
mock_index_cls, mock_emb_cls, mock_vdb_cls = mock_indexing_deps
_register_legacy()
_setup_mock_index(mock_index_cls, "doc-celery")
mock_emb_cls.return_value = MagicMock()
mock_vdb_cls.return_value = MagicMock()
mock_get_fs.return_value = MagicMock()
ctx = _make_index_context()
task = eager_app.tasks["execute_extraction"]
result_dict = task.apply(args=[ctx.to_dict()]).get()
result = ExecutionResult.from_dict(result_dict)
assert result.success is True
assert result.data[IKeys.DOC_ID] == "doc-celery"
# --- 9. Index class receives correct DTOs ---
class TestIndexDTOs:
@patch(_PATCH_FS)
def test_index_created_with_correct_dtos(
self, mock_get_fs, mock_indexing_deps
):
mock_index_cls, mock_emb_cls, mock_vdb_cls = mock_indexing_deps
_register_legacy()
executor = ExecutorRegistry.get("legacy")
_setup_mock_index(mock_index_cls, "doc-dto")
mock_emb_cls.return_value = MagicMock()
mock_vdb_cls.return_value = MagicMock()
mock_get_fs.return_value = MagicMock()
ctx = _make_index_context(
executor_params={
"embedding_instance_id": "emb-dto",
"vector_db_instance_id": "vdb-dto",
"x2text_instance_id": "x2t-dto",
"file_path": "/data/doc.pdf",
"file_hash": "hash-dto",
"extracted_text": "text",
"platform_api_key": "sk-test",
"chunk_size": 256,
"chunk_overlap": 64,
"tool_id": "tool-dto",
"tags": ["tag1"],
}
)
executor.execute(ctx)
init_kwargs = mock_index_cls.call_args.kwargs
ids = init_kwargs["instance_identifiers"]
assert ids.embedding_instance_id == "emb-dto"
assert ids.vector_db_instance_id == "vdb-dto"
assert ids.x2text_instance_id == "x2t-dto"
assert ids.tool_id == "tool-dto"
assert ids.tags == ["tag1"]
chunking = init_kwargs["chunking_config"]
assert chunking.chunk_size == 256
assert chunking.chunk_overlap == 64
gen_call = mock_index_cls.return_value.generate_index_key.call_args
fi = gen_call.kwargs["file_info"]
assert fi.file_path == "/data/doc.pdf"
assert fi.file_hash == "hash-dto"
# --- 10. EmbeddingCompat and VectorDB created with correct params ---
class TestAdapterCreation:
@patch(_PATCH_FS)
def test_embedding_and_vectordb_params(
self, mock_get_fs, mock_indexing_deps
):
mock_index_cls, mock_emb_cls, mock_vdb_cls = mock_indexing_deps
_register_legacy()
executor = ExecutorRegistry.get("legacy")
_setup_mock_index(mock_index_cls, "doc-adapt")
mock_emb = MagicMock()
mock_emb_cls.return_value = mock_emb
mock_vdb = MagicMock()
mock_vdb_cls.return_value = mock_vdb
mock_get_fs.return_value = MagicMock()
ctx = _make_index_context(
executor_params={
"embedding_instance_id": "emb-check",
"vector_db_instance_id": "vdb-check",
"x2text_instance_id": "x2t-001",
"file_path": "/data/test.pdf",
"file_hash": "abc",
"extracted_text": "text",
"platform_api_key": "sk-test",
"chunk_size": 512,
"chunk_overlap": 128,
"usage_kwargs": {"org": "test-org"},
}
)
executor.execute(ctx)
emb_call = mock_emb_cls.call_args
assert emb_call.kwargs["adapter_instance_id"] == "emb-check"
assert emb_call.kwargs["kwargs"] == {"org": "test-org"}
vdb_call = mock_vdb_cls.call_args
assert vdb_call.kwargs["adapter_instance_id"] == "vdb-check"
assert vdb_call.kwargs["embedding"] is mock_emb