"""
Unit tests for manifest corruption handling.
GAP #1: Manifest reconciliation with corrupted data (High/Low, Score 4.0)
"""
import json
import pytest
from src.indexing.manifest import IndexManifest, load_manifest, save_manifest
from src.indexing.reconciler import reconcile_indices, build_indexed_files_map
@pytest.fixture
def docs_path(tmp_path):
"""Create a temporary documents directory."""
docs = tmp_path / "docs"
docs.mkdir()
return docs
def test_load_manifest_corrupted_json_returns_none(tmp_path):
"""
Return None when manifest JSON is corrupted.
Tests that corrupted JSON is handled gracefully without crashing.
Existing test verifies this, but explicitly testing corruption recovery.
"""
manifest_path = tmp_path / "index.manifest.json"
manifest_path.write_text("{ invalid json, missing brace")
loaded = load_manifest(tmp_path)
assert loaded is None
def test_load_manifest_truncated_json_returns_none(tmp_path):
"""
Return None when manifest JSON is truncated mid-write.
Simulates partial write due to crash or disk full.
"""
manifest_path = tmp_path / "index.manifest.json"
# Truncated JSON - starts valid but cuts off
manifest_path.write_text('{"spec_version": "1.0.0", "embedding_model": "test", ')
loaded = load_manifest(tmp_path)
assert loaded is None
def test_load_manifest_with_null_values_returns_none(tmp_path):
"""
Return None when manifest has null values for required fields.
Tests handling of incomplete/corrupted manifest data.
"""
manifest_path = tmp_path / "index.manifest.json"
manifest_path.write_text(json.dumps({
"spec_version": None,
"embedding_model": "test-model",
"parsers": {},
"chunking_config": {}
}))
loaded = load_manifest(tmp_path)
# Should fail because spec_version is None
assert loaded is None or loaded.spec_version is None
def test_load_manifest_with_wrong_types_returns_none(tmp_path):
"""
Return None when manifest fields have wrong types.
Tests type validation during manifest loading.
Note: Current implementation doesn't validate types during load.
This test verifies that wrong types don't crash loading.
"""
manifest_path = tmp_path / "index.manifest.json"
manifest_path.write_text(json.dumps({
"spec_version": "1.0.0",
"embedding_model": "test-model",
"parsers": "should_be_dict_not_string",
"chunking_config": {}
}))
loaded = load_manifest(tmp_path)
# Current implementation loads without type validation
# This test verifies it doesn't crash (future: add validation)
assert loaded is not None
def test_reconcile_with_corrupted_indexed_files_handles_gracefully(docs_path):
"""
Reconcile handles corrupted indexed_files field gracefully.
Tests that reconciliation works even when indexed_files data is malformed.
"""
# Create manifest with valid structure but unusual indexed_files
manifest = IndexManifest(
spec_version="1.0.0",
embedding_model="local",
parsers={},
chunking_config={},
indexed_files=None # Corrupted state - should be dict
)
# Create actual files
(docs_path / "doc1.md").write_text("# Doc 1")
discovered = [str(docs_path / "doc1.md")]
# Should handle None indexed_files
files_to_add, doc_ids_to_remove, _ = reconcile_indices(
discovered,
manifest,
docs_path
)
assert len(files_to_add) == 1
assert doc_ids_to_remove == []
def test_reconcile_with_empty_strings_in_indexed_files(docs_path):
"""
Reconcile handles empty strings in indexed_files mapping.
Tests robustness against malformed manifest data.
"""
manifest = IndexManifest(
spec_version="1.0.0",
embedding_model="local",
parsers={},
chunking_config={},
indexed_files={
"": "empty.md", # Empty doc_id
"valid": "valid.md",
}
)
(docs_path / "valid.md").write_text("# Valid")
discovered = [str(docs_path / "valid.md")]
# Should handle empty doc_id gracefully
files_to_add, doc_ids_to_remove, _ = reconcile_indices(
discovered,
manifest,
docs_path
)
# Empty string doc_id should be considered stale
assert "" in doc_ids_to_remove
assert files_to_add == []
def test_save_and_load_manifest_with_special_characters(tmp_path):
"""
Manifest handles file paths with special characters.
Tests that special characters in paths don't corrupt manifest.
"""
manifest = IndexManifest(
spec_version="1.0.0",
embedding_model="test-model",
parsers={"**/*.md": "MarkdownParser"},
chunking_config={},
indexed_files={
"file with spaces": "file with spaces.md",
"file-with-dashes": "file-with-dashes.md",
"file_with_underscores": "file_with_underscores.md",
"file.with.dots": "file.with.dots.md",
}
)
save_manifest(tmp_path, manifest)
loaded = load_manifest(tmp_path)
assert loaded is not None
assert loaded.indexed_files == manifest.indexed_files
def test_build_indexed_files_map_with_duplicate_doc_ids(docs_path):
"""
Handle duplicate file paths that resolve to same doc_id.
GAP #13: build_indexed_files_map with duplicates (Medium/Low, Score 3.33)
Tests that duplicate doc_ids are handled (last one wins).
"""
# Create files with same name in different locations
# (This shouldn't happen normally, but test robustness)
(docs_path / "doc.md").write_text("# Doc 1")
subdir = docs_path / "subdir"
subdir.mkdir()
(subdir / "doc.md").write_text("# Doc 2")
files = [
str(docs_path / "doc.md"),
str(subdir / "doc.md"),
]
indexed_map = build_indexed_files_map(files, docs_path)
# Both should be in map with different doc_ids
assert "doc" in indexed_map
assert "subdir/doc" in indexed_map
assert len(indexed_map) == 2
def test_reconcile_with_absolute_and_relative_path_mix(docs_path, tmp_path):
"""
Reconcile handles mix of absolute and relative paths.
Tests path normalization in reconciliation.
"""
manifest = IndexManifest(
spec_version="1.0.0",
embedding_model="local",
parsers={},
chunking_config={},
indexed_files={"doc1": "doc1.md"}
)
(docs_path / "doc1.md").write_text("# Doc 1")
(docs_path / "doc2.md").write_text("# Doc 2")
# Mix absolute paths (discovered) with relative (manifest)
discovered = [
str(docs_path / "doc1.md"),
str(docs_path / "doc2.md"),
]
files_to_add, doc_ids_to_remove, _ = reconcile_indices(
discovered,
manifest,
docs_path
)
# Should normalize paths correctly
assert len(files_to_add) == 1
assert str(docs_path / "doc2.md") in files_to_add
assert doc_ids_to_remove == []
