diet-guard/diet_guard/tests/test_prune_peers.py

"""Tests for pruning device directories nothing writes to any more.

This is the one command that *deletes* data on a shared remote, so the tests
lean on the refusals rather than the happy path: a protected id, a peer with a
record no one else has, and ``--apply`` without a backup must each stop it.
"""

from __future__ import annotations

import json
from typing import TYPE_CHECKING
from unittest.mock import MagicMock

from diet_guard import _cli, _cli_prune, _prune_peers
from diet_guard._device import device_id

if TYPE_CHECKING:
    from pathlib import Path

    import pytest


def _client(logs: dict[str, dict[str, object]]) -> MagicMock:
    """Return a client whose devices publish the given record-id maps."""
    client = MagicMock()
    client.list_directory.return_value = list(logs)
    files = {
        f"diet-guard-sync/devices/{dev}/food_log.json": json.dumps(recs)
        for dev, recs in logs.items()
    }
    client.get_file_text.side_effect = files.get
    return client


class TestPlanPrune:
    """Deciding what may go, without touching anything."""

    def test_a_covered_peer_is_prunable(self) -> None:
        """Every record already held by a kept device -> nothing is lost."""
        client = _client({"live": {"r1": {}, "r2": {}}, "dead": {"r1": {}}})

        plan = _prune_peers.plan_prune(client, {"live"})

        assert plan.prunes == ["dead"]
        assert plan.unique_lost == 0

    def test_a_peer_with_a_unique_record_is_kept(self) -> None:
        """One unheld record is enough to disqualify a peer from deletion."""
        client = _client({"live": {"r1": {}}, "hoarder": {"r1": {}, "r9": {}}})

        plan = _prune_peers.plan_prune(client, {"live"})

        assert plan.prunes == []
        assert plan.unique_lost == 1

    def test_legacy_role_ids_are_never_proposed(self) -> None:
        """Dropping one makes every tick re-merge our own pre-migration log."""
        client = _client({"live": {"r1": {}}, "pc": {}, "phone": {}, "desktop": {}})

        plan = _prune_peers.plan_prune(client, {"live"})

        assert plan.prunes == []
        assert set(plan.keeps) >= {"pc", "phone", "desktop"}

    def test_this_device_is_never_proposed(self) -> None:
        client = _client({device_id(): {"r1": {}}, "live": {"r1": {}}})

        plan = _prune_peers.plan_prune(client, {"live"})

        assert device_id() not in plan.prunes

    def test_an_unreadable_peer_log_counts_as_empty(self) -> None:
        """Unparsable is not "unique" -- it must not block an otherwise safe plan."""
        client = _client({"live": {"r1": {}}})
        client.list_directory.return_value = ["live", "broken"]
        client.get_file_text.side_effect = lambda p: (
            "{not json" if "broken" in p else json.dumps({"r1": {}})
        )

        plan = _prune_peers.plan_prune(client, {"live"})

        assert plan.prunes == ["broken"]

    def test_a_peer_that_never_pushed_is_prunable(self) -> None:
        client = _client({"live": {"r1": {}}})
        client.list_directory.return_value = ["live", "empty"]
        client.get_file_text.side_effect = lambda p: (
            None if "empty" in p else json.dumps({"r1": {}})
        )

        plan = _prune_peers.plan_prune(client, {"live"})

        assert plan.prunes == ["empty"]


class TestApply:
    """The destructive half."""

    def test_backup_writes_every_published_path(self, tmp_path: Path) -> None:
        client = MagicMock()
        client.get_file_text.return_value = "{}"

        written = _prune_peers.backup_peers(client, ["dead"], tmp_path)

        assert written == 5  # log, food bank, curated bank, budget, rev
        assert (tmp_path / "dead" / "food_log.json").read_text() == "{}"

    def test_backup_skips_paths_a_device_never_published(self, tmp_path: Path) -> None:
        client = MagicMock()
        client.get_file_text.return_value = None

        assert _prune_peers.backup_peers(client, ["dead"], tmp_path) == 0

    def test_apply_deletes_the_revision_marker_too(self) -> None:
        """Leaving it behind makes the narrow pull slower, not faster.

        ``_sync_refresh._candidate_peers`` enumerates peers from the revision
        map, so an orphaned marker resurrects a deleted device as a candidate
        and costs a round trip every tick. Observed for real: pruning without
        this took the narrow pull from ~90ms to ~15s.
        """
        client = MagicMock()

        list(_prune_peers.apply_prune(client, ["dead"]))

        deleted = [call.args[0] for call in client.delete_file.call_args_list]
        assert "diet-guard-sync/revs/dead" in deleted

    def test_apply_deletes_all_four_paths(self) -> None:
        client = MagicMock()

        assert list(_prune_peers.apply_prune(client, ["dead"])) == ["dead"]
        assert client.delete_file.call_count == 5


class TestCommand:
    """The CLI wrapper, whose defaults are the real safety rail."""

    def _run(
        self,
        monkeypatch: pytest.MonkeyPatch,
        client: MagicMock,
        **kwargs: object,
    ) -> tuple[int, list[str]]:
        monkeypatch.setattr(_prune_peers, "_client_for_run", lambda: client)
        out: list[str] = []
        opts = {"keep": ["live"], "backup_dir": None, "apply": False, **kwargs}
        code = _cli_prune.cmd_prune_peers(out.append, **opts)
        return code, out

    def test_dry_run_deletes_nothing(self, monkeypatch: pytest.MonkeyPatch) -> None:
        client = _client({"live": {"r1": {}}, "dead": {"r1": {}}})

        code, out = self._run(monkeypatch, client)

        assert code == 0
        client.delete_file.assert_not_called()
        assert any("dry run" in line for line in out)

    def test_apply_without_a_backup_dir_refuses(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        client = _client({"live": {"r1": {}}, "dead": {"r1": {}}})

        code, out = self._run(monkeypatch, client, apply=True)

        assert code == 1
        client.delete_file.assert_not_called()
        assert any("refusing to delete" in line for line in out)

    def test_an_unsafe_plan_refuses(self, monkeypatch: pytest.MonkeyPatch) -> None:
        client = _client({"live": {"r1": {}}, "hoarder": {"r1": {}, "r9": {}}})

        code, out = self._run(monkeypatch, client, apply=True)

        assert code == 1
        client.delete_file.assert_not_called()
        assert any("exist only on" in line for line in out)

    def test_nothing_to_prune_is_reported(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        client = _client({"live": {"r1": {}}})

        code, out = self._run(monkeypatch, client)

        assert code == 0
        assert any("nothing to prune" in line for line in out)

    def test_apply_backs_up_then_deletes(
        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
    ) -> None:
        client = _client({"live": {"r1": {}}, "dead": {"r1": {}}})

        code, out = self._run(monkeypatch, client, apply=True, backup_dir=str(tmp_path))

        assert code == 0
        assert client.delete_file.call_count == 5
        assert any("pruned 1 device" in line for line in out)

    def test_main_dispatches_the_subcommand(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        """The argparse flags reach the handler unpacked."""
        seen: dict[str, object] = {}

        def _fake(_emit: object, **kwargs: object) -> int:
            seen.update(kwargs)
            return 0

        monkeypatch.setattr(_cli, "cmd_prune_peers", _fake)

        assert _cli.main(["prune-peers", "--keep", "abc"]) == 0
        assert seen == {"keep": ["abc"], "backup_dir": None, "apply": False}