Blame for generator/code/tests/test_map_cache.py

from __future__ import annotations

import bz2
from dataclasses import fields
import gzip
import hashlib
import json
import multiprocessing
import os
from pathlib import Path
import time

import numpy as np
import pandas as pd
import pytest

from simulator.config import Config
import simulator.empirical_maps as empirical_maps_module
import simulator.map_cache as map_cache_module
from simulator.empirical_maps import (
    PiecewiseRateMap,
    load_empirical_maps,
    load_empirical_rate_table,
)
from simulator.map_cache import (
    ARRAY_FIELDS,
    CACHE_ENV_VAR,
    CACHE_SCHEMA,
    build_cache_fingerprint,
    load_or_build_rate_maps,
    map_cache_directory,
)


def _write_interval_map(path: Path) -> None:
    path.write_text(
        "chr2 0 100 1e-8\n"
        "chr1 0 50 2e-8\n"
        "chr1 50 120 3e-8\n"
        "chr2 100 200 4e-8\n",
        encoding="utf-8",
    )


def _raw_sha256(array: np.ndarray) -> str:
    return hashlib.sha256(np.asarray(array).tobytes(order="C")).hexdigest()


def _assert_maps_exact(
    expected: dict[str, PiecewiseRateMap],
    actual: dict[str, PiecewiseRateMap],
) -> None:
    assert list(actual) == list(expected)
    scalar_fields = [
        field.name
        for field in fields(PiecewiseRateMap)
        if field.name not in ARRAY_FIELDS
    ]
    for chrom in expected:
        expected_map = expected[chrom]
        actual_map = actual[chrom]
        for field in scalar_fields:
            expected_value = getattr(expected_map, field)
            actual_value = getattr(actual_map, field)
            assert type(actual_value) is type(expected_value)
            assert actual_value == expected_value
        for field in ARRAY_FIELDS:
            expected_array = np.asarray(getattr(expected_map, field))
            actual_array = np.asarray(getattr(actual_map, field))
            assert actual_array.dtype == expected_array.dtype
            assert actual_array.shape == expected_array.shape
            assert actual_array.nbytes == expected_array.nbytes
            assert _raw_sha256(actual_array) == _raw_sha256(expected_array)
            assert actual_array.tobytes(order="C") == expected_array.tobytes(order="C")


def _cache_entries(cache_dir: Path) -> list[Path]:
    return sorted(
        path
        for path in cache_dir.iterdir()
        if path.is_dir() and not path.name.startswith(".")
    )


def _concurrent_cache_worker(
    source_text: str,
    cache_dir_text: str,
    counter_text: str,
    gate,
    result_queue,
) -> None:
    os.environ[CACHE_ENV_VAR] = cache_dir_text
    source = Path(source_text)
    counter = Path(counter_text)

    def builder(snapshot: Path) -> dict[str, PiecewiseRateMap]:
        descriptor = os.open(counter, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600)
        try:
            os.write(descriptor, f"{os.getpid()}\n".encode("ascii"))
        finally:
            os.close(descriptor)
        time.sleep(0.25)
        return load_empirical_rate_table(
            str(snapshot),
            baseline_rate=1e-8,
            map_kind="recombination",
            rate_unit="per_bp",
            scale_to_baseline=False,
        )

    gate.wait(timeout=10)
    maps = load_or_build_rate_maps(
        source_path=source,
        parse_parameters={
            "parser": "concurrency-test",
            "baseline_rate": 1e-8,
            "map_kind": "recombination",
            "rate_unit": "per_bp",
            "scale_to_baseline": False,
        },
        related_code_paths={"test_parser": Path(__file__)},
        builder=builder,
        map_class=PiecewiseRateMap,
    )
    first = next(iter(maps.values()))
    result_queue.put(
        (
            type(first.position).__name__,
            first.position.dtype.str,
            first.position.shape,
            _raw_sha256(first.position),
        )
    )


def test_fingerprint_covers_source_parameters_schema_code_and_versions(
    tmp_path: Path,
) -> None:
    source = tmp_path / "map.bed"
    parser_code = tmp_path / "parser.py"
    _write_interval_map(source)
    parser_code.write_text("PARSER_VERSION = 1\n", encoding="utf-8")
    parameters = {
        "baseline_rate": 1e-8,
        "map_kind": "recombination",
        "rate_unit": "per_bp",
        "scale_to_baseline": False,
    }

    fingerprint, payload = build_cache_fingerprint(
        source,
        parameters,
        {"parser": parser_code},
    )

    assert len(fingerprint) == 64
    assert payload["schema"] == CACHE_SCHEMA
    assert payload["source"] == {
        "name": source.name,
        "size": source.stat().st_size,
        "sha256": hashlib.sha256(source.read_bytes()).hexdigest(),
    }
    assert payload["parse_parameters"] == parameters
    implementation = payload["implementation"]
    assert implementation["numpy_version"] == np.__version__
    assert implementation["pandas_version"] == pd.__version__
    assert implementation["python_version"]
    assert implementation["platform"]
    assert implementation["machine"]
    assert implementation["byteorder"] in {"little", "big"}
    assert implementation["code_sha256"]["parser"] == hashlib.sha256(
        parser_code.read_bytes()
    ).hexdigest()
    assert "cache_schema_implementation" in implementation["code_sha256"]

    changed_parameters = {**parameters, "scale_to_baseline": True}
    changed_parameter_fingerprint, _ = build_cache_fingerprint(
        source,
        changed_parameters,
        {"parser": parser_code},
    )
    assert changed_parameter_fingerprint != fingerprint

    parser_code.write_text("PARSER_VERSION = 2\n", encoding="utf-8")
    changed_code_fingerprint, _ = build_cache_fingerprint(
        source,
        parameters,
        {"parser": parser_code},
    )
    assert changed_code_fingerprint != fingerprint

    source.write_text(source.read_text(encoding="utf-8") + "chr3 0 10 5e-8\n", encoding="utf-8")
    changed_source_fingerprint, _ = build_cache_fingerprint(
        source,
        parameters,
        {"parser": parser_code},
    )
    assert changed_source_fingerprint not in {fingerprint, changed_code_fingerprint}


def test_cached_load_is_mmap_and_strictly_matches_uncached_parser(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    source = tmp_path / "map.bed"
    cache_dir = tmp_path / "cache"
    _write_interval_map(source)
    monkeypatch.setenv(CACHE_ENV_VAR, str(cache_dir))
    cfg = Config(
        recomb_map=str(source),
        mut_map="",
        baseline_rec=1e-8,
        recomb_map_unit="per_bp",
    )
    direct = load_empirical_rate_table(
        str(source),
        baseline_rate=cfg.baseline_rec,
        map_kind="recombination",
        rate_unit=cfg.recomb_map_unit,
        scale_to_baseline=False,
    )

    first = load_empirical_maps(cfg)
    _assert_maps_exact(direct, first.rec_maps)
    assert all(
        isinstance(getattr(rate_map, field), np.memmap)
        and not getattr(rate_map, field).flags.writeable
        for rate_map in first.rec_maps.values()
        for field in ARRAY_FIELDS
    )
    assert first.metadata["recombination"] == empirical_maps_module._summarize_maps(
        str(source),
        direct,
        cfg.recomb_map_unit,
    )
    assert first.metadata["recombination"]["source_size_bytes"] == source.stat().st_size
    assert first.metadata["recombination"]["source_sha256"] == hashlib.sha256(
        source.read_bytes()
    ).hexdigest()
    assert map_cache_directory() == cache_dir.resolve()

    entries = _cache_entries(cache_dir)
    assert len(entries) == 1
    manifest = json.loads((entries[0] / "manifest.json").read_text(encoding="utf-8"))
    assert manifest["schema"] == CACHE_SCHEMA
    assert manifest["fingerprint"] == entries[0].name
    assert len(manifest["maps"]) == len(direct)
    fingerprint_payload = manifest["fingerprint_payload"]
    assert fingerprint_payload["source"]["sha256"] == hashlib.sha256(source.read_bytes()).hexdigest()
    assert fingerprint_payload["parse_parameters"] == {
        "parser": "load_empirical_rate_table",
        "compression": "none",
        "baseline_rate": cfg.baseline_rec,
        "map_kind": "recombination",
        "rate_unit": cfg.recomb_map_unit,
        "scale_to_baseline": False,
    }
    assert set(fingerprint_payload["implementation"]["code_sha256"]) == {
        "cache_schema_implementation",
        "empirical_maps_parser",
        "rate_validation_config",
    }
    assert not list(cache_dir.glob(".*.tmp-*"))
    assert not list(cache_dir.glob(".*.source-*"))

    def cache_miss_is_a_failure(*_args, **_kwargs):
        raise AssertionError("a valid cache hit must not invoke the text parser")

    monkeypatch.setattr(
        empirical_maps_module,
        "load_empirical_rate_table",
        cache_miss_is_a_failure,
    )
    second = load_empirical_maps(cfg)
    _assert_maps_exact(direct, second.rec_maps)


def test_loaded_recombination_and_mutation_metadata_record_source_provenance(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    recombination = tmp_path / "recombination.bed"
    mutation = tmp_path / "mutation.bed"
    cache_dir = tmp_path / "cache"
    _write_interval_map(recombination)
    _write_interval_map(mutation)
    mutation.write_text(
        mutation.read_text(encoding="utf-8").replace("1e-8", "1.25e-8"),
        encoding="utf-8",
    )
    monkeypatch.setenv(CACHE_ENV_VAR, str(cache_dir))

    store = load_empirical_maps(
        Config(
            recomb_map=str(recombination),
            mut_map=str(mutation),
            recomb_map_unit="per_bp",
            mut_map_unit="per_bp",
        )
    )

    for kind, source in (
        ("recombination", recombination),
        ("mutation", mutation),
    ):
        metadata = store.metadata[kind]
        assert metadata["source_size_bytes"] == source.stat().st_size
        assert metadata["source_sha256"] == hashlib.sha256(source.read_bytes()).hexdigest()


def test_corrupt_array_or_scalar_metadata_is_safely_rebuilt(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    source = tmp_path / "map.bed"
    cache_dir = tmp_path / "cache"
    _write_interval_map(source)
    monkeypatch.setenv(CACHE_ENV_VAR, str(cache_dir))
    cfg = Config(recomb_map=str(source), mut_map="", recomb_map_unit="per_bp")
    direct = load_empirical_rate_table(
        str(source),
        cfg.baseline_rec,
        map_kind="recombination",
        rate_unit=cfg.recomb_map_unit,
        scale_to_baseline=False,
    )
    load_empirical_maps(cfg)
    entry = _cache_entries(cache_dir)[0]
    manifest_path = entry / "manifest.json"
    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
    array_path = entry / manifest["maps"][0]["arrays"]["position"]["file"]
    array_path.write_bytes(b"not a valid npy")

    original_parser = empirical_maps_module.load_empirical_rate_table
    parser_calls = 0

    def counted_parser(*args, **kwargs):
        nonlocal parser_calls
        parser_calls += 1
        return original_parser(*args, **kwargs)

    monkeypatch.setattr(
        empirical_maps_module,
        "load_empirical_rate_table",
        counted_parser,
    )
    rebuilt_from_array_damage = load_empirical_maps(cfg)
    assert parser_calls == 1
    _assert_maps_exact(direct, rebuilt_from_array_damage.rec_maps)

    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
    manifest["maps"][0]["scalars"]["source_format"] = "corrupt-but-valid-json"
    manifest_path.write_text(json.dumps(manifest), encoding="utf-8")

    rebuilt_from_metadata_damage = load_empirical_maps(cfg)
    assert parser_calls == 2
    _assert_maps_exact(direct, rebuilt_from_metadata_damage.rec_maps)
    repaired_manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
    assert repaired_manifest["maps"][0]["scalars"]["source_format"] == "bed_intervals"

    repaired_manifest["maps"][0]["scalars"]["mean_rate_before_scaling"] = float("nan")
    manifest_path.write_text(json.dumps(repaired_manifest), encoding="utf-8")

    rebuilt_from_nonfinite_json = load_empirical_maps(cfg)
    assert parser_calls == 3
    _assert_maps_exact(direct, rebuilt_from_nonfinite_json.rec_maps)
    repaired_manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
    assert np.isfinite(
        repaired_manifest["maps"][0]["scalars"]["mean_rate_before_scaling"]
    )
    assert not list(cache_dir.glob(".*.previous-*"))
    assert not list(cache_dir.glob(".*.tmp-*"))


def test_cache_hit_rechecks_source_before_returning(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    source = tmp_path / "map.bed"
    cache_dir = tmp_path / "cache"
    _write_interval_map(source)
    monkeypatch.setenv(CACHE_ENV_VAR, str(cache_dir))
    cfg = Config(recomb_map=str(source), mut_map="")
    initial = load_empirical_maps(cfg)
    initial_rate_sha256 = _raw_sha256(initial.rec_maps["chr1"].rate)

    original_load_entry = map_cache_module._load_entry
    source_changed = False

    def load_entry_after_source_change(*args, **kwargs):
        nonlocal source_changed
        if not source_changed:
            source_changed = True
            source.write_text(
                source.read_text(encoding="utf-8").replace(
                    "chr1 50 120 3e-8",
                    "chr1 50 120 9e-8",
                ),
                encoding="utf-8",
            )
        return original_load_entry(*args, **kwargs)

    original_parser = empirical_maps_module.load_empirical_rate_table
    parser_calls = 0

    def counted_parser(*args, **kwargs):
        nonlocal parser_calls
        parser_calls += 1
        return original_parser(*args, **kwargs)

    monkeypatch.setattr(map_cache_module, "_load_entry", load_entry_after_source_change)
    monkeypatch.setattr(
        empirical_maps_module,
        "load_empirical_rate_table",
        counted_parser,
    )

    actual = load_empirical_maps(cfg)
    expected = original_parser(
        str(source),
        cfg.baseline_rec,
        map_kind="recombination",
        rate_unit=cfg.recomb_map_unit,
        scale_to_baseline=False,
    )

    assert source_changed
    assert parser_calls == 1
    _assert_maps_exact(expected, actual.rec_maps)
    assert _raw_sha256(actual.rec_maps["chr1"].rate) != initial_rate_sha256
    assert len(_cache_entries(cache_dir)) == 2


def test_cache_build_rechecks_source_after_publishing(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    source = tmp_path / "map.bed"
    cache_dir = tmp_path / "cache"
    _write_interval_map(source)
    monkeypatch.setenv(CACHE_ENV_VAR, str(cache_dir))
    cfg = Config(recomb_map=str(source), mut_map="")

    original_publish = map_cache_module._build_and_publish
    source_changed = False

    def publish_then_change_source(*args, **kwargs):
        nonlocal source_changed
        original_publish(*args, **kwargs)
        if not source_changed:
            source_changed = True
            source.write_text(
                source.read_text(encoding="utf-8").replace(
                    "chr1 50 120 3e-8",
                    "chr1 50 120 8e-8",
                ),
                encoding="utf-8",
            )

    original_parser = empirical_maps_module.load_empirical_rate_table
    parser_calls = 0

    def counted_parser(*args, **kwargs):
        nonlocal parser_calls
        parser_calls += 1
        return original_parser(*args, **kwargs)

    monkeypatch.setattr(
        map_cache_module,
        "_build_and_publish",
        publish_then_change_source,
    )
    monkeypatch.setattr(
        empirical_maps_module,
        "load_empirical_rate_table",
        counted_parser,
    )

    actual = load_empirical_maps(cfg)
    expected = original_parser(
        str(source),
        cfg.baseline_rec,
        map_kind="recombination",
        rate_unit=cfg.recomb_map_unit,
        scale_to_baseline=False,
    )

    assert source_changed
    assert parser_calls == 2
    _assert_maps_exact(expected, actual.rec_maps)
    assert len(_cache_entries(cache_dir)) == 2


def test_unavailable_cache_falls_back_without_swallowing_parser_errors(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    source = tmp_path / "map.bed"
    blocked_cache_path = tmp_path / "cache-is-a-file"
    _write_interval_map(source)
    blocked_cache_path.write_text("not a directory\n", encoding="utf-8")
    monkeypatch.setenv(CACHE_ENV_VAR, str(blocked_cache_path))
    cfg = Config(recomb_map=str(source), mut_map="")
    direct = load_empirical_rate_table(
        str(source),
        cfg.baseline_rec,
        map_kind="recombination",
        rate_unit=cfg.recomb_map_unit,
        scale_to_baseline=False,
    )

    with pytest.warns(RuntimeWarning, match="falling back to direct text parsing"):
        fallback = load_empirical_maps(cfg)

    _assert_maps_exact(direct, fallback.rec_maps)
    assert all(
        not isinstance(getattr(rate_map, field), np.memmap)
        for rate_map in fallback.rec_maps.values()
        for field in ARRAY_FIELDS
    )
    assert blocked_cache_path.is_file()

    def cache_root_resolution_failure() -> Path:
        raise OSError("cache root resolution failure")

    monkeypatch.setattr(
        map_cache_module,
        "map_cache_directory",
        cache_root_resolution_failure,
    )
    with pytest.warns(RuntimeWarning, match="falling back to direct text parsing"):
        resolution_fallback = load_empirical_maps(cfg)
    _assert_maps_exact(direct, resolution_fallback.rec_maps)

    def scientific_parser_failure(*_args, **_kwargs):
        raise ValueError("scientific parser failure")

    monkeypatch.setattr(
        empirical_maps_module,
        "load_empirical_rate_table",
        scientific_parser_failure,
    )
    with pytest.warns(RuntimeWarning, match="falling back to direct text parsing"):
        with pytest.raises(ValueError, match="scientific parser failure"):
            load_empirical_maps(cfg)


def test_crash_residue_is_cleaned_and_missing_entry_is_rebuilt(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    source = tmp_path / "map.bed"
    cache_dir = tmp_path / "cache"
    _write_interval_map(source)
    monkeypatch.setenv(CACHE_ENV_VAR, str(cache_dir))
    cfg = Config(recomb_map=str(source), mut_map="")
    direct = load_empirical_rate_table(
        str(source),
        cfg.baseline_rec,
        map_kind="recombination",
        rate_unit=cfg.recomb_map_unit,
        scale_to_baseline=False,
    )
    load_empirical_maps(cfg)
    entry = _cache_entries(cache_dir)[0]
    fingerprint = entry.name
    previous = cache_dir / f".{fingerprint}.previous-crashed"
    staging = cache_dir / f".{fingerprint}.tmp-crashed"
    snapshot = cache_dir / f".{fingerprint}.source-crashed"
    entry.replace(previous)
    staging.mkdir()
    (staging / "partial.npy").write_bytes(b"partial")
    snapshot.write_bytes(b"partial source snapshot")

    original_parser = empirical_maps_module.load_empirical_rate_table
    parser_calls = 0

    def counted_parser(*args, **kwargs):
        nonlocal parser_calls
        parser_calls += 1
        return original_parser(*args, **kwargs)

    monkeypatch.setattr(
        empirical_maps_module,
        "load_empirical_rate_table",
        counted_parser,
    )
    rebuilt = load_empirical_maps(cfg)

    assert parser_calls == 1
    _assert_maps_exact(direct, rebuilt.rec_maps)
    assert (cache_dir / fingerprint).is_dir()
    assert not previous.exists()
    assert not staging.exists()
    assert not snapshot.exists()


def test_source_content_change_uses_a_new_cache_entry(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    source = tmp_path / "map.bed"
    cache_dir = tmp_path / "cache"
    _write_interval_map(source)
    monkeypatch.setenv(CACHE_ENV_VAR, str(cache_dir))
    cfg = Config(recomb_map=str(source), mut_map="")

    before = load_empirical_maps(cfg)
    before_sha = _raw_sha256(before.rec_maps["chr1"].rate)
    source.write_text(
        source.read_text(encoding="utf-8").replace("chr1 50 120 3e-8", "chr1 50 120 7e-8"),
        encoding="utf-8",
    )
    direct_after = load_empirical_rate_table(
        str(source),
        cfg.baseline_rec,
        map_kind="recombination",
        rate_unit=cfg.recomb_map_unit,
        scale_to_baseline=False,
    )
    after = load_empirical_maps(cfg)

    _assert_maps_exact(direct_after, after.rec_maps)
    assert _raw_sha256(after.rec_maps["chr1"].rate) != before_sha
    assert len(_cache_entries(cache_dir)) == 2


def test_cache_preserves_symlink_filename_compression_semantics(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    compressed_target = tmp_path / "compressed-map-data.bin"
    with gzip.open(compressed_target, "wt", encoding="utf-8") as handle:
        handle.write("chr1 0 100 1e-8\nchr1 100 200 2e-8\n")
    source_alias = tmp_path / "map.bed.gz"
    try:
        source_alias.symlink_to(compressed_target)
    except OSError as exc:
        pytest.skip(f"symbolic links are unavailable: {exc}")

    monkeypatch.setenv(CACHE_ENV_VAR, str(tmp_path / "cache"))
    cfg = Config(recomb_map=str(source_alias), mut_map="")
    direct = load_empirical_rate_table(
        str(source_alias),
        cfg.baseline_rec,
        map_kind="recombination",
        rate_unit=cfg.recomb_map_unit,
        scale_to_baseline=False,
    )

    cached = load_empirical_maps(cfg)

    _assert_maps_exact(direct, cached.rec_maps)
    entry = _cache_entries(tmp_path / "cache")[0]
    manifest = json.loads((entry / "manifest.json").read_text(encoding="utf-8"))
    assert manifest["fingerprint_payload"]["parse_parameters"]["compression"] == "gzip"


def test_cache_preserves_plain_alias_to_misleading_gzip_filename(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    plain_target = tmp_path / "plain-text-map.gz"
    plain_target.write_text(
        "chr1 0 100 1e-8\nchr1 100 200 2e-8\n",
        encoding="utf-8",
    )
    source_alias = tmp_path / "map.bed"
    try:
        source_alias.symlink_to(plain_target)
    except OSError as exc:
        pytest.skip(f"symbolic links are unavailable: {exc}")

    monkeypatch.setenv(CACHE_ENV_VAR, str(tmp_path / "cache"))
    cfg = Config(recomb_map=str(source_alias), mut_map="")
    direct = load_empirical_rate_table(
        str(source_alias),
        cfg.baseline_rec,
        map_kind="recombination",
        rate_unit=cfg.recomb_map_unit,
        scale_to_baseline=False,
    )

    cached = load_empirical_maps(cfg)

    _assert_maps_exact(direct, cached.rec_maps)
    entry = _cache_entries(tmp_path / "cache")[0]
    manifest = json.loads((entry / "manifest.json").read_text(encoding="utf-8"))
    assert manifest["fingerprint_payload"]["parse_parameters"]["compression"] == "none"


def test_cache_preserves_legacy_non_gzip_codec_inference(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    source = tmp_path / "map.bed.bz2"
    with bz2.open(source, "wt", encoding="utf-8") as handle:
        handle.write("chr1 0 100 1e-8\nchr1 100 200 2e-8\n")

    monkeypatch.setenv(CACHE_ENV_VAR, str(tmp_path / "cache"))
    cfg = Config(recomb_map=str(source), mut_map="")
    direct = load_empirical_rate_table(
        str(source),
        cfg.baseline_rec,
        map_kind="recombination",
        rate_unit=cfg.recomb_map_unit,
        scale_to_baseline=False,
    )

    cached = load_empirical_maps(cfg)

    _assert_maps_exact(direct, cached.rec_maps)
    entry = _cache_entries(tmp_path / "cache")[0]
    manifest = json.loads((entry / "manifest.json").read_text(encoding="utf-8"))
    assert manifest["fingerprint_payload"]["parse_parameters"]["compression"] == "bz2"


def test_symlink_retarget_during_build_cannot_poison_resolved_source_cache(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    target_a = tmp_path / "target-a.bed"
    target_b = tmp_path / "target-b.bed"
    source_alias = tmp_path / "map-alias.bed"
    target_a.write_text("chr1 0 100 1e-8\n", encoding="utf-8")
    target_b.write_text("chr1 0 100 9e-8\n", encoding="utf-8")
    try:
        source_alias.symlink_to(target_a)
    except OSError as exc:
        pytest.skip(f"symbolic links are unavailable: {exc}")

    monkeypatch.setenv(CACHE_ENV_VAR, str(tmp_path / "cache"))
    direct_a = load_empirical_rate_table(
        str(target_a),
        baseline_rate=1e-8,
        map_kind="recombination",
        rate_unit=Config().recomb_map_unit,
        scale_to_baseline=False,
    )
    direct_b = load_empirical_rate_table(
        str(target_b),
        baseline_rate=1e-8,
        map_kind="recombination",
        rate_unit=Config().recomb_map_unit,
        scale_to_baseline=False,
    )
    original_load_entry = map_cache_module._load_entry
    retargeted = False

    def load_entry_after_retarget(*args, **kwargs):
        nonlocal retargeted
        if not retargeted:
            retargeted = True
            source_alias.unlink()
            source_alias.symlink_to(target_b)
        return original_load_entry(*args, **kwargs)

    monkeypatch.setattr(
        map_cache_module,
        "_load_entry",
        load_entry_after_retarget,
    )
    through_alias = load_empirical_maps(
        Config(recomb_map=str(source_alias), mut_map="")
    )
    later_direct_target_hit = load_empirical_maps(
        Config(recomb_map=str(target_a), mut_map="")
    )

    assert retargeted
    _assert_maps_exact(direct_a, through_alias.rec_maps)
    _assert_maps_exact(direct_a, later_direct_target_hit.rec_maps)
    assert _raw_sha256(
        later_direct_target_hit.rec_maps["chr1"].rate
    ) != _raw_sha256(direct_b["chr1"].rate)


def test_builder_parses_verified_snapshot_during_aba_source_change(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    source = tmp_path / "map.bed"
    source_a = "chr1 0 100 1e-8\n"
    source_b = "chr1 0 100 9e-8\n"
    source.write_text(source_a, encoding="utf-8")
    monkeypatch.setenv(CACHE_ENV_VAR, str(tmp_path / "cache"))
    cfg = Config(recomb_map=str(source), mut_map="")
    direct_a = load_empirical_rate_table(
        str(source),
        cfg.baseline_rec,
        map_kind="recombination",
        rate_unit=cfg.recomb_map_unit,
        scale_to_baseline=False,
    )
    original_parser = empirical_maps_module.load_empirical_rate_table
    parser_calls = 0

    def parse_while_original_source_changes(path, *args, **kwargs):
        nonlocal parser_calls
        parser_calls += 1
        source.write_text(source_b, encoding="utf-8")
        try:
            return original_parser(path, *args, **kwargs)
        finally:
            source.write_text(source_a, encoding="utf-8")

    monkeypatch.setattr(
        empirical_maps_module,
        "load_empirical_rate_table",
        parse_while_original_source_changes,
    )
    first = load_empirical_maps(cfg)
    second = load_empirical_maps(cfg)

    assert parser_calls == 1
    _assert_maps_exact(direct_a, first.rec_maps)
    _assert_maps_exact(direct_a, second.rec_maps)


def test_concurrent_processes_build_one_atomic_entry(
    tmp_path: Path,
) -> None:
    source = tmp_path / "map.bed"
    cache_dir = tmp_path / "cache"
    counter = tmp_path / "builder-calls.txt"
    _write_interval_map(source)
    context = multiprocessing.get_context("spawn")
    gate = context.Event()
    result_queue = context.Queue()
    processes = [
        context.Process(
            target=_concurrent_cache_worker,
            args=(
                str(source),
                str(cache_dir),
                str(counter),
                gate,
                result_queue,
            ),
        )
        for _ in range(2)
    ]
    for process in processes:
        process.start()
    gate.set()
    for process in processes:
        process.join(timeout=20)
        if process.is_alive():
            process.terminate()
            process.join(timeout=5)

    assert [process.exitcode for process in processes] == [0, 0]
    results = [result_queue.get(timeout=2) for _ in processes]
    assert results[0] == results[1]
    assert results[0][0] == "memmap"
    assert len(counter.read_text(encoding="utf-8").splitlines()) == 1
    assert len(_cache_entries(cache_dir)) == 1
    assert not list(cache_dir.glob(".*.tmp-*"))
    assert not list(cache_dir.glob(".*.previous-*"))
    assert not list(cache_dir.glob(".*.source-*"))