"""Tests for report generation tools."""
import pytest
from datetime import datetime
from pathlib import Path
from registry_review_mcp.tools import report_tools, session_tools, document_tools, evidence_tools, mapping_tools
from registry_review_mcp.models.report import (
ReportMetadata,
RequirementFinding,
ValidationFinding,
ReportSummary,
)
@pytest.mark.usefixtures("cleanup_sessions")
class TestMarkdownReportGeneration:
"""Test Markdown report generation."""
async def test_generate_markdown_report_structure(self, tmp_path):
"""Test that Markdown report has correct structure."""
# Create session with mock data
session = await session_tools.create_session(
project_name="Test Project",
documents_path=str(tmp_path),
methodology="soil-carbon-v1.2.2"
)
session_id = session["session_id"]
# Generate report (will use placeholder data)
result = await report_tools.generate_review_report(
session_id=session_id,
format="markdown"
)
assert result["format"] == "markdown"
assert "report_path" in result
assert result["session_id"] == session_id
# Verify file was created
report_path = Path(result["report_path"])
assert report_path.exists()
assert report_path.suffix == ".md"
# Read and check content structure
content = report_path.read_text()
assert "# Registry Agent Review" in content or "Registry Review" in content
assert "Project Metadata" in content or "Project:" in content
assert "Summary" in content
async def test_markdown_report_includes_requirements(self, tmp_path):
"""Test that Markdown report includes requirement findings."""
session = await session_tools.create_session(
project_name="Test Project",
documents_path=str(tmp_path),
methodology="soil-carbon-v1.2.2"
)
session_id = session["session_id"]
result = await report_tools.generate_review_report(
session_id=session_id,
format="markdown"
)
content = Path(result["report_path"]).read_text()
# Should have requirements section
assert "Requirements" in content or "REQ-" in content
async def test_markdown_report_includes_citations(self, tmp_path):
"""Test that Markdown report includes page citations."""
example_path = Path(__file__).parent.parent / "examples" / "22-23"
if not example_path.exists():
pytest.skip("Botany Farm example data not available")
session = await session_tools.create_session(
project_name="Botany Farm",
documents_path=str(example_path),
methodology="soil-carbon-v1.2.2"
)
session_id = session["session_id"]
# Discover documents and extract evidence
await document_tools.discover_documents(session_id)
await mapping_tools.map_all_requirements(session_id)
await evidence_tools.extract_all_evidence(session_id)
# Generate report
result = await report_tools.generate_review_report(
session_id=session_id,
format="markdown"
)
content = Path(result["report_path"]).read_text()
# Should have page citations (format: "Page X" or "DOC-XXX, Page X")
assert "Page" in content or "page" in content
@pytest.mark.usefixtures("cleanup_sessions")
class TestJSONReportGeneration:
"""Test JSON report generation."""
async def test_generate_json_report_structure(self, tmp_path):
"""Test that JSON report has correct structure."""
session = await session_tools.create_session(
project_name="Test Project",
documents_path=str(tmp_path),
methodology="soil-carbon-v1.2.2"
)
session_id = session["session_id"]
result = await report_tools.generate_review_report(
session_id=session_id,
format="json"
)
assert result["format"] == "json"
assert "report_path" in result
# Verify file was created
report_path = Path(result["report_path"])
assert report_path.exists()
assert report_path.suffix == ".json"
# Read and validate JSON structure
import json
with open(report_path) as f:
report_data = json.load(f)
assert "metadata" in report_data
assert "summary" in report_data
assert "requirements" in report_data
assert isinstance(report_data["requirements"], list)
async def test_json_report_is_valid_json(self, tmp_path):
"""Test that generated JSON is valid and parseable."""
session = await session_tools.create_session(
project_name="Test Project",
documents_path=str(tmp_path),
methodology="soil-carbon-v1.2.2"
)
session_id = session["session_id"]
result = await report_tools.generate_review_report(
session_id=session_id,
format="json"
)
# This should not raise an exception
import json
with open(result["report_path"]) as f:
report_data = json.load(f)
# Basic validation
assert report_data["metadata"]["session_id"] == session_id
assert "project_name" in report_data["metadata"]
@pytest.mark.usefixtures("cleanup_sessions")
class TestReportFormatting:
"""Test report formatting and content."""
async def test_format_requirement_finding(self, tmp_path):
"""Test formatting of individual requirement findings."""
# Test the helper function for formatting requirement findings
finding = {
"requirement_id": "REQ-001",
"requirement_text": "Test requirement text",
"status": "covered",
"confidence": 0.95,
"mapped_documents": [{"document_id": "DOC-001"}],
"evidence_snippets": [
{
"text": "Test evidence",
"page": 5,
"section": "1.1 Introduction"
}
]
}
formatted = report_tools.format_requirement_markdown(finding)
# format_requirement_markdown returns a list of strings
formatted_text = "\n".join(formatted)
assert "REQ-001" in formatted_text
assert "covered" in formatted_text.lower() or "✅" in formatted_text
assert "0.95" in formatted_text or "95" in formatted_text
async def test_format_validation_summary(self, tmp_path):
"""Test formatting of validation summary."""
validations = {
"date_alignments": [
{"status": "pass", "message": "Test pass"}
],
"land_tenure": [
{"status": "warning", "message": "Test warning"}
],
"project_ids": [
{"status": "fail", "message": "Test fail"}
]
}
formatted = report_tools.format_validation_summary_markdown(validations)
# format_validation_summary_markdown returns a list of strings
formatted_text = "\n".join(formatted)
assert "pass" in formatted_text.lower() or "✅" in formatted_text
assert "warning" in formatted_text.lower() or "⚠" in formatted_text
assert "fail" in formatted_text.lower() or "❌" in formatted_text
@pytest.mark.usefixtures("cleanup_sessions")
class TestReportExport:
"""Test report export functionality."""
async def test_export_both_formats(self, tmp_path):
"""Test exporting report in both Markdown and JSON."""
session = await session_tools.create_session(
project_name="Test Project",
documents_path=str(tmp_path),
methodology="soil-carbon-v1.2.2"
)
session_id = session["session_id"]
# Generate both formats
md_result = await report_tools.generate_review_report(
session_id=session_id,
format="markdown"
)
json_result = await report_tools.generate_review_report(
session_id=session_id,
format="json"
)
# Both should exist
assert Path(md_result["report_path"]).exists()
assert Path(json_result["report_path"]).exists()
# Should be different files
assert md_result["report_path"] != json_result["report_path"]
class TestCompleteWorkflow:
"""Test complete report generation workflow."""
async def test_full_report_workflow(self, tmp_path):
"""Test complete workflow from session to report."""
example_path = Path(__file__).parent.parent / "examples" / "22-23"
if not example_path.exists():
pytest.skip("Botany Farm example data not available")
# Initialize
session = await session_tools.create_session(
project_name="Botany Farm",
documents_path=str(example_path),
methodology="soil-carbon-v1.2.2"
)
session_id = session["session_id"]
# Discovery
docs = await document_tools.discover_documents(session_id)
assert docs["documents_found"] > 0
# Mapping
await mapping_tools.map_all_requirements(session_id)
# Extraction
evidence = await evidence_tools.extract_all_evidence(session_id)
assert evidence["requirements_total"] == 23
# Report Generation
report = await report_tools.generate_review_report(
session_id=session_id,
format="markdown"
)
assert Path(report["report_path"]).exists()
content = Path(report["report_path"]).read_text()
assert "Botany Farm" in content
assert len(content) > 1000 # Should be substantial
