{
  pkgs,
  ...
}:
let
  script = ../services/monero/xmrig-auto-pause.py;
  python = pkgs.python3;
in
pkgs.testers.runNixOSTest {
  name = "xmrig-auto-pause";

  nodes.machine =
    { pkgs, ... }:
    {
      environment.systemPackages = [
        pkgs.python3
        pkgs.procps
      ];

      # Mock xmrig as a nice'd sleep process that can be stopped/started.
      systemd.services.xmrig = {
        description = "Mock xmrig miner";
        serviceConfig = {
          ExecStart = "${pkgs.coreutils}/bin/sleep infinity";
          Type = "simple";
          Nice = 19;
        };
        wantedBy = [ "multi-user.target" ];
      };
    };

  testScript = ''
    import time

    PYTHON = "${python}/bin/python3"
    SCRIPT = "${script}"

    # Tuned for test VMs (1-2 cores).
    # POLL_INTERVAL=1 keeps detection latency low.
    # GRACE_PERIOD=5 is long enough to verify "stays stopped" but short
    # enough that the full test completes in reasonable time.
    # CPU_THRESHOLD=10 catches a single busy-loop on a 1-2 core VM.
    POLL_INTERVAL = "1"
    GRACE_PERIOD = "5"
    CPU_THRESHOLD = "10"
    STARTUP_COOLDOWN = "4"

    def start_cpu_load(name):
        """Start a non-nice CPU burn as a transient systemd unit."""
        machine.succeed(
            f"systemd-run --unit={name} --property=Type=exec "
            f"bash -c 'while true; do :; done'"
        )

    def stop_cpu_load(name):
        machine.succeed(f"systemctl stop {name}")

    start_all()
    machine.wait_for_unit("multi-user.target")
    machine.wait_for_unit("xmrig.service")

    with subtest("Start auto-pause monitor"):
        machine.succeed(
            f"systemd-run --unit=xmrig-auto-pause "
            f"--setenv=POLL_INTERVAL={POLL_INTERVAL} "
            f"--setenv=GRACE_PERIOD={GRACE_PERIOD} "
            f"--setenv=CPU_THRESHOLD={CPU_THRESHOLD} "
            f"--setenv=STARTUP_COOLDOWN={STARTUP_COOLDOWN} "
            f"{PYTHON} {SCRIPT}"
        )
        # Monitor needs two consecutive polls to compute a CPU delta.
        time.sleep(3)

    with subtest("xmrig stays running while system is idle"):
        machine.succeed("systemctl is-active xmrig")

    with subtest("xmrig stopped when CPU load appears"):
        start_cpu_load("cpu-load")
        machine.wait_until_fails("systemctl is-active xmrig", timeout=20)

    with subtest("xmrig remains stopped during grace period after load ends"):
        stop_cpu_load("cpu-load")
        # Load just stopped. Grace period is 5s. Check at 2s — well within.
        time.sleep(2)
        machine.fail("systemctl is-active xmrig")

    with subtest("xmrig resumes after grace period expires"):
        # Already idle since previous subtest. Grace period (5s) plus
        # detection delay (~2 polls) plus startup cooldown (4s) means
        # xmrig should restart within ~12s.
        machine.wait_until_succeeds("systemctl is-active xmrig", timeout=20)

    with subtest("Intermittent load does not cause flapping"):
        # First load — stop xmrig
        start_cpu_load("cpu-load-1")
        machine.wait_until_fails("systemctl is-active xmrig", timeout=20)
        stop_cpu_load("cpu-load-1")

        # Brief idle gap — shorter than grace period
        time.sleep(2)

        # Second load arrives before grace period expires
        start_cpu_load("cpu-load-2")
        time.sleep(3)

        # xmrig must still be stopped
        machine.fail("systemctl is-active xmrig")

        stop_cpu_load("cpu-load-2")
        machine.wait_until_succeeds("systemctl is-active xmrig", timeout=20)

    with subtest("Sustained load keeps xmrig stopped"):
        start_cpu_load("cpu-load-3")
        machine.wait_until_fails("systemctl is-active xmrig", timeout=20)

        # Stay busy longer than the grace period to prove continuous
        # activity keeps xmrig stopped indefinitely.
        time.sleep(8)
        machine.fail("systemctl is-active xmrig")

        stop_cpu_load("cpu-load-3")
        machine.wait_until_succeeds("systemctl is-active xmrig", timeout=20)

    with subtest("External restart detected and re-stopped under load"):
        # Put system under load so auto-pause stops xmrig.
        start_cpu_load("cpu-load-4")
        machine.wait_until_fails("systemctl is-active xmrig", timeout=20)

        # Something external starts xmrig while load is active.
        # The script should detect this and re-stop it.
        machine.succeed("systemctl start xmrig")
        machine.succeed("systemctl is-active xmrig")
        machine.wait_until_fails("systemctl is-active xmrig", timeout=20)

        stop_cpu_load("cpu-load-4")
        machine.wait_until_succeeds("systemctl is-active xmrig", timeout=20)
  '';
}