Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /Consiliency_treesitter-chunker /tests /test_export_json.py
| """Tests for JSON export functionality.""" | |
| import gzip | |
| import json | |
| from pathlib import Path | |
| import pytest | |
| from chunker.export import JSONExporter, SchemaType | |
| from chunker.types import CodeChunk | |
| def sample_chunks(): | |
| """Create sample chunks with relationships.""" | |
| chunks = [ | |
| CodeChunk( | |
| language="python", | |
| file_path="test.py", | |
| node_type="class_definition", | |
| start_line=1, | |
| end_line=10, | |
| byte_start=0, | |
| byte_end=200, | |
| parent_context="", | |
| content="class TestClass:\n pass", | |
| chunk_id="chunk1", | |
| parent_chunk_id=None, | |
| metadata={"kind": "class", "semantic_text": "class TestClass"}, | |
| ), | |
| CodeChunk( | |
| language="python", | |
| file_path="test.py", | |
| node_type="method_definition", | |
| start_line=3, | |
| end_line=5, | |
| byte_start=50, | |
| byte_end=100, | |
| parent_context="class_definition", | |
| content="def method(self):\n pass", | |
| chunk_id="chunk2", | |
| parent_chunk_id="chunk1", | |
| metadata={"kind": "method", "semantic_text": "method TestClass.method"}, | |
| ), | |
| ] | |
| return chunks | |
| def test_json_export_flat_schema(sample_chunks): | |
| """Test JSON export with flat schema.""" | |
| exporter = JSONExporter(SchemaType.FLAT) | |
| result = exporter.export_to_string(sample_chunks) | |
| data = json.loads(result) | |
| assert isinstance(data, list) | |
| assert len(data) == 2 | |
| assert data[0]["chunk_id"] == "chunk1" | |
| assert data[1]["parent_chunk_id"] == "chunk1" | |
| def test_json_export_nested_schema(sample_chunks): | |
| """Test JSON export with nested schema.""" | |
| exporter = JSONExporter(SchemaType.NESTED) | |
| result = exporter.export_to_string(sample_chunks) | |
| data = json.loads(result) | |
| assert isinstance(data, list) | |
| assert len(data) == 1 # Only root chunk | |
| assert data[0]["chunk_id"] == "chunk1" | |
| assert len(data[0]["children"]) == 1 | |
| assert data[0]["children"][0]["chunk_id"] == "chunk2" | |
| def test_json_export_minimal_schema(sample_chunks): | |
| """Test JSON export with minimal schema.""" | |
| exporter = JSONExporter(SchemaType.MINIMAL) | |
| result = exporter.export_to_string(sample_chunks) | |
| data = json.loads(result) | |
| assert isinstance(data, list) | |
| assert len(data) == 2 | |
| assert "id" in data[0] | |
| assert "type" in data[0] | |
| assert "content" in data[0] | |
| assert "chunk_id" not in data[0] # Minimal schema | |
| def test_json_export_full_schema(sample_chunks): | |
| """Test JSON export with full schema.""" | |
| exporter = JSONExporter(SchemaType.FULL) | |
| result = exporter.export_to_string(sample_chunks) | |
| data = json.loads(result) | |
| assert isinstance(data, dict) | |
| assert "metadata" in data | |
| assert "chunks" in data | |
| assert "relationships" in data | |
| assert data["metadata"]["total_chunks"] == 2 | |
| assert len(data["chunks"]) == 2 | |
| assert len(data["relationships"]["parent_child"]) == 1 | |
| def test_json_export_preserves_metadata(sample_chunks): | |
| """Test JSON export retains chunk metadata when present.""" | |
| exporter = JSONExporter(SchemaType.FLAT) | |
| result = exporter.export_to_string(sample_chunks) | |
| data = json.loads(result) | |
| assert data[0]["metadata"]["kind"] == "class" | |
| assert data[1]["metadata"]["semantic_text"] == "method TestClass.method" | |
| def test_json_export_to_file(sample_chunks, tmp_path): | |
| """Test JSON export to file.""" | |
| exporter = JSONExporter(SchemaType.FLAT) | |
| output_path = tmp_path / "output.json" | |
| exporter.export(sample_chunks, output_path) | |
| assert output_path.exists() | |
| with Path(output_path).open( | |
| "r", | |
| encoding="utf-8", | |
| ) as f: | |
| data = json.load(f) | |
| assert len(data) == 2 | |
| def test_json_export_compressed(sample_chunks, tmp_path): | |
| """Test JSON export with compression.""" | |
| exporter = JSONExporter(SchemaType.FLAT) | |
| output_path = tmp_path / "output.json" | |
| exporter.export(sample_chunks, output_path, compress=True) | |
| compressed_path = Path(f"{output_path}.gz") | |
| assert compressed_path.exists() | |
| with gzip.open(compressed_path, "rt") as f: | |
| data = json.load(f) | |
| assert len(data) == 2 | |
| def test_structured_json_exporter_compress_writes_gzip(sample_chunks, tmp_path): | |
| """StructuredJSONExporter(compress=True) must produce a readable .gz file. | |
| IFACE gzip.Path bug: the exporter called the nonexistent ``gzip.Path`` API, | |
| so compress=True raised AttributeError. It must use gzip.open and round-trip. | |
| """ | |
| from chunker.export.formats.json import StructuredJSONExporter | |
| exporter = StructuredJSONExporter(compress=True) | |
| output_path = tmp_path / "structured.json" | |
| exporter.export(sample_chunks, [], output_path) | |
| gz = Path(f"{output_path}.gz") | |
| assert gz.exists(), "compress=True did not write the .gz file" | |
| with gzip.open(gz, "rt", encoding="utf-8") as f: | |
| data = json.load(f) | |
| assert len(data["chunks"]) == 2 | |
| def test_json_export_custom_indent(sample_chunks): | |
| """Test JSON export with custom indentation.""" | |
| exporter = JSONExporter(SchemaType.FLAT) | |
| # No indent | |
| result_compact = exporter.export_to_string(sample_chunks, indent=None) | |
| assert "\n" not in result_compact.strip() | |
| # With indent | |
| result_pretty = exporter.export_to_string(sample_chunks, indent=4) | |
| assert "\n" in result_pretty | |
| assert " " in result_pretty # 4 spaces | |
Xet Storage Details
- Size:
- 5.51 kB
- Xet hash:
- cb6961e0f05e5fdc65a3ef1dc110867a879516a6bac1d1d0efcedaa35693724b
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.