Add in-process unit tests for foundry and ingestion CLIs

Foundry config/orchestrator/CLI and the ingestion CLI were only exercised by
the subprocess end-to-end test, so coverage was not attributed to their
packages. Add in-process tests covering config loading/validation, the full
pipeline run with artifact assertions, and CLI dry-run/full-run paths.

Foundry coverage 50% -> 90%, ingestion 76% -> 81%.

Author: DiogoRibeiro7

tests/test_foundry_cli.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from llm_dataset_foundry.cli import main as cli
+
+EXAMPLES = Path(__file__).resolve().parent.parent / "examples"
+
+
+def _write_config(tmp_path: Path) -> Path:
+    docs = (EXAMPLES / "normalized-documents" / "documents.jsonl").as_posix()
+    interactions = (EXAMPLES / "traces" / "interactions.jsonl").as_posix()
+    retrieval = (EXAMPLES / "traces" / "retrieval.jsonl").as_posix()
+    out = tmp_path / "out"
+    config_path = tmp_path / "foundry.yaml"
+    config_path.write_text(
+        f"""
+ingest:
+  normalized_documents_file: {docs}
+  interaction_events_file: {interactions}
+  retrieval_events_file: {retrieval}
+dataset:
+  dataset_name: example-dataset
+  dataset_id: example-ds
+  dataset_version: v1
+quality:
+  dedup_enabled: true
+  min_text_length: 5
+splits:
+  seed: 42
+  train_ratio: 0.8
+  validation_ratio: 0.1
+  test_ratio: 0.1
+output:
+  curated_dataset_path: {(out / "curated").as_posix()}
+  reports_path: {(out / "reports").as_posix()}
+  manifests_path: {(out / "manifests").as_posix()}
+""",
+        encoding="utf-8",
+    )
+    return config_path
+
+
+def test_build_parser_defaults() -> None:
+    args = cli.build_parser().parse_args([])
+    assert args.config == "configs/foundry.yaml"
+    assert args.dry_run is False
+
+
+def test_cli_dry_run_validates_without_writing(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    config_path = _write_config(tmp_path)
+    monkeypatch.setattr("sys.argv", ["prog", "--config", str(config_path), "--dry-run"])
+
+    assert cli.main() == 0
+    out = capsys.readouterr().out
+    assert "Dry run successful" in out
+    assert "example-ds@v1" in out
+    # Dry run must not produce any artifacts.
+    assert not (tmp_path / "out").exists()
+
+
+def test_cli_full_run_builds_dataset(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    config_path = _write_config(tmp_path)
+    monkeypatch.setattr("sys.argv", ["prog", "--config", str(config_path)])
+
+    assert cli.main() == 0
+    out = capsys.readouterr().out
+    assert "Dataset build completed" in out
+    assert (tmp_path / "out" / "curated" / "prompt_response.jsonl").exists()

tests/test_foundry_config.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from llm_dataset_foundry.pipeline.config import (
+    DatasetSettings,
+    IngestSettings,
+    QualitySettings,
+    SplitSettings,
+    load_config,
+)
+
+VALID_CONFIG = """
+ingest:
+  normalized_documents_file: docs.jsonl
+  interaction_events_file: interactions.jsonl
+  retrieval_events_file: retrieval.jsonl
+dataset:
+  dataset_name: example-dataset
+  dataset_id: example-ds
+  dataset_version: v1
+quality:
+  dedup_enabled: true
+  min_text_length: 5
+splits:
+  seed: 7
+  train_ratio: 0.8
+  validation_ratio: 0.1
+  test_ratio: 0.1
+output:
+  curated_dataset_path: out/curated
+  reports_path: out/reports
+  manifests_path: out/manifests
+"""
+
+
+def _write(tmp_path: Path, text: str) -> Path:
+    config_path = tmp_path / "foundry.yaml"
+    config_path.write_text(text, encoding="utf-8")
+    return config_path
+
+
+def test_load_config_resolves_relative_paths_and_defaults(tmp_path: Path) -> None:
+    config = load_config(_write(tmp_path, VALID_CONFIG))
+
+    # Relative paths resolve against the config file's directory.
+    assert config.ingest.normalized_documents_file == tmp_path / "docs.jsonl"
+    assert config.output.curated_dataset_path == tmp_path / "out" / "curated"
+    # Unspecified keys fall back to documented defaults.
+    assert config.ingest.max_records == 10000
+    assert config.dataset.schema_version == "1.0"
+    assert config.dataset.model_version == "unknown-model"
+
+
+def test_load_config_keeps_absolute_paths(tmp_path: Path) -> None:
+    absolute = (tmp_path / "elsewhere" / "docs.jsonl").as_posix()
+    text = VALID_CONFIG.replace("normalized_documents_file: docs.jsonl", f"normalized_documents_file: {absolute}")
+    config = load_config(_write(tmp_path, text))
+    assert config.ingest.normalized_documents_file == Path(absolute)
+
+
+def test_load_config_rejects_non_mapping_payload(tmp_path: Path) -> None:
+    with pytest.raises(ValueError, match="must be a mapping"):
+        load_config(_write(tmp_path, "- just\n- a\n- list\n"))
+
+
+def test_load_config_rejects_non_mapping_section(tmp_path: Path) -> None:
+    text = VALID_CONFIG.replace("quality:\n  dedup_enabled: true\n  min_text_length: 5", "quality: not-a-mapping")
+    with pytest.raises(ValueError, match="Config key 'quality' must be a mapping"):
+        load_config(_write(tmp_path, text))
+
+
+def test_ingest_settings_rejects_non_positive_max_records(tmp_path: Path) -> None:
+    with pytest.raises(ValueError, match="max_records must be > 0"):
+        IngestSettings(
+            normalized_documents_file=tmp_path / "a",
+            interaction_events_file=tmp_path / "b",
+            retrieval_events_file=tmp_path / "c",
+            max_records=0,
+        )
+
+
+def test_dataset_settings_rejects_empty_name() -> None:
+    with pytest.raises(ValueError, match="dataset_name must not be empty"):
+        DatasetSettings(
+            dataset_name="   ",
+            dataset_id="id",
+            dataset_version="v1",
+            schema_version="1.0",
+            model_version="m",
+        )
+
+
+def test_quality_settings_rejects_non_positive_min_length() -> None:
+    with pytest.raises(ValueError, match="min_text_length must be > 0"):
+        QualitySettings(dedup_enabled=True, min_text_length=0)
+
+
+def test_split_settings_rejects_ratios_not_summing_to_one() -> None:
+    with pytest.raises(ValueError, match="must sum to 1.0"):
+        SplitSettings(seed=1, train_ratio=0.5, validation_ratio=0.1, test_ratio=0.1)
+
+
+def test_split_settings_rejects_non_positive_ratio() -> None:
+    with pytest.raises(ValueError, match="must be > 0"):
+        SplitSettings(seed=1, train_ratio=0.9, validation_ratio=0.1, test_ratio=0.0)

tests/test_foundry_pipeline.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from llm_dataset_foundry.pipeline.config import load_config
+from llm_dataset_foundry.pipeline.orchestrator import DatasetFoundryPipeline
+
+EXAMPLES = Path(__file__).resolve().parent.parent / "examples"
+
+
+def _config_text(out: Path) -> str:
+    docs = (EXAMPLES / "normalized-documents" / "documents.jsonl").as_posix()
+    interactions = (EXAMPLES / "traces" / "interactions.jsonl").as_posix()
+    retrieval = (EXAMPLES / "traces" / "retrieval.jsonl").as_posix()
+    return f"""
+ingest:
+  normalized_documents_file: {docs}
+  interaction_events_file: {interactions}
+  retrieval_events_file: {retrieval}
+  max_records: 1000
+dataset:
+  dataset_name: example-dataset
+  dataset_id: example-ds
+  dataset_version: v1
+  schema_version: "1.0"
+  model_version: example-model-v1
+quality:
+  dedup_enabled: true
+  min_text_length: 5
+splits:
+  seed: 42
+  train_ratio: 0.8
+  validation_ratio: 0.1
+  test_ratio: 0.1
+output:
+  curated_dataset_path: {(out / "curated").as_posix()}
+  reports_path: {(out / "reports").as_posix()}
+  manifests_path: {(out / "manifests").as_posix()}
+"""
+
+
+def _run(tmp_path: Path):
+    config_path = tmp_path / "foundry.yaml"
+    config_path.write_text(_config_text(tmp_path / "out"), encoding="utf-8")
+    config = load_config(config_path)
+    result = DatasetFoundryPipeline(config=config).run()
+    return config, result
+
+
+def test_pipeline_run_loads_example_data(tmp_path: Path) -> None:
+    _, result = _run(tmp_path)
+    assert result.documents_loaded > 0
+    assert result.interaction_traces_loaded > 0
+    assert result.retrieval_traces_loaded > 0
+    assert result.prompt_response_records > 0
+    assert result.retrieval_eval_records > 0
+
+
+def test_pipeline_writes_all_artifacts(tmp_path: Path) -> None:
+    config, _ = _run(tmp_path)
+    curated = config.output.curated_dataset_path
+    reports = config.output.reports_path
+    manifests = config.output.manifests_path
+
+    for name in ("prompt_response.jsonl", "retrieval_evaluation.jsonl", "split_assignments.jsonl"):
+        assert (curated / name).exists(), name
+    assert (reports / "quality_report.json").exists()
+    assert (manifests / "dataset_manifest.json").exists()
+    assert (manifests / "dataset_version_metadata.json").exists()
+
+
+def test_manifest_is_valid_json_with_expected_fields(tmp_path: Path) -> None:
+    config, result = _run(tmp_path)
+    manifest = json.loads((config.output.manifests_path / "dataset_manifest.json").read_text(encoding="utf-8"))
+    assert manifest["dataset_id"] == "example-ds"
+    assert manifest["dataset_version"] == "v1"
+    assert manifest["model_version"] == "example-model-v1"
+    counts = manifest["record_counts"]
+    assert counts["prompt_response"] == result.prompt_response_records
+    assert counts["retrieval_evaluation"] == result.retrieval_eval_records
+    # Split buckets always present, and sum to the total record count.
+    assert counts["train"] + counts["validation"] + counts["test"] == (
+        result.prompt_response_records + result.retrieval_eval_records
+    )
+
+
+def test_split_assignments_cover_every_record(tmp_path: Path) -> None:
+    config, result = _run(tmp_path)
+    lines = (
+        (config.output.curated_dataset_path / "split_assignments.jsonl")
+        .read_text(encoding="utf-8")
+        .splitlines()
+    )
+    assert len(lines) == result.prompt_response_records + result.retrieval_eval_records
+    for line in lines:
+        row = json.loads(line)
+        assert row["split"] in {"train", "validation", "test"}
+        assert row["record_id"]

tests/test_foundry_surface.py

@@ -0,0 +1,37 @@
+"""Smoke coverage for the foundry public surface: re-export modules, the
+lightweight value objects, and the source-adapter interface contract."""
+
+from __future__ import annotations
+
+from llm_dataset_foundry.contracts import entities
+from llm_dataset_foundry.contracts.models import DatasetManifest
+from llm_dataset_foundry.ingest.interfaces import SourceAdapter
+from llm_dataset_foundry.quality.models import QualityCheckResult
+from llm_dataset_foundry.reports.specs import ReportSpec
+from llm_dataset_foundry.versioning import manifest
+
+
+def test_reexport_modules_expose_expected_names() -> None:
+    assert "PromptResponseTrainingExample" in entities.__all__
+    assert manifest.DatasetManifest is DatasetManifest
+
+
+def test_quality_check_result_holds_fields() -> None:
+    result = QualityCheckResult(check_name="min_length", passed=False, message="too short")
+    assert result.check_name == "min_length"
+    assert result.passed is False
+    assert result.message == "too short"
+
+
+def test_report_spec_holds_fields() -> None:
+    spec = ReportSpec(report_name="quality", generated_for_version="v1")
+    assert spec.report_name == "quality"
+    assert spec.generated_for_version == "v1"
+
+
+def test_source_adapter_subclass_implements_read() -> None:
+    class StaticAdapter(SourceAdapter):
+        def read(self) -> list[dict[str, object]]:
+            return [{"document_id": "doc-1"}]
+
+    assert StaticAdapter().read() == [{"document_id": "doc-1"}]

tests/test_ingestion_cli.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from llm_knowledge_ingestion.cli import main as cli
+
+
+def _write_config(tmp_path: Path) -> Path:
+    input_dir = tmp_path / "input"
+    input_dir.mkdir()
+    (input_dir / "doc1.txt").write_text("A short sample document for ingestion.", encoding="utf-8")
+
+    out = tmp_path / "out"
+    config_path = tmp_path / "ingestion.yaml"
+    config_path.write_text(
+        f"""
+ingestion:
+  source_id: test-source
+  input_path: {input_dir.as_posix()}
+  max_documents: 5
+chunking:
+  strategy: fixed_tokens
+  target_tokens: 5
+  overlap_tokens: 1
+output:
+  normalized_documents_path: {(out / "documents").as_posix()}
+  chunks_path: {(out / "chunks").as_posix()}
+  lineage_path: {(out / "lineage").as_posix()}
+  index_records_path: {(out / "index").as_posix()}
+  run_result_path: {(out / "run" / "ingestion_result.json").as_posix()}
+""",
+        encoding="utf-8",
+    )
+    return config_path
+
+
+def test_build_parser_defaults() -> None:
+    args = cli.build_parser().parse_args([])
+    assert args.config == "configs/ingestion.yaml"
+    assert args.dry_run is False
+
+
+def test_cli_dry_run_selects_documents_without_writing(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    config_path = _write_config(tmp_path)
+    monkeypatch.setattr("sys.argv", ["prog", "--config", str(config_path), "--dry-run"])
+
+    assert cli.main() == 0
+    out = capsys.readouterr().out
+    assert "Dry run successful" in out
+    assert "1 document(s) selected" in out
+    assert not (tmp_path / "out").exists()
+
+
+def test_cli_full_run_produces_artifacts(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    config_path = _write_config(tmp_path)
+    monkeypatch.setattr("sys.argv", ["prog", "--config", str(config_path)])
+
+    assert cli.main() == 0
+    out = capsys.readouterr().out
+    assert "Ingestion completed" in out
+    assert (tmp_path / "out" / "documents" / "documents.jsonl").exists()