629 lines
27 KiB
Python
629 lines
27 KiB
Python
#!/usr/bin/env python3
|
|
"""Unit tests for auto_suspend.py.
|
|
|
|
Subprocess calls are intercepted; test data comes from real command
|
|
outputs captured on gpu-01.lab.alexpires.me and stored under ``fixtures/``.
|
|
"""
|
|
|
|
import json
|
|
import os
|
|
import signal
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
from unittest.mock import patch, MagicMock
|
|
|
|
FIXTURES = Path(__file__).parent / "fixtures"
|
|
|
|
|
|
def _load_fixture(name):
|
|
"""Load a fixture file and return its content as a string."""
|
|
return FIXTURES.joinpath(name).read_text()
|
|
|
|
|
|
def _make_mock_result(stdout="", returncode=0, stderr=""):
|
|
return MagicMock(
|
|
returncode=returncode,
|
|
stdout=stdout,
|
|
stderr=stderr,
|
|
)
|
|
|
|
|
|
def _make_mock_timeout():
|
|
return subprocess.TimeoutExpired(cmd=["test"], timeout=5)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Fixtures (real samples from gpu-01)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
MPSTAT_IDLE = _load_fixture("mpstat--1--1.idle.txt")
|
|
NVIDIA_IDLE = _load_fixture("nvidia-smi--query-gpu.utilization.gpu.csv.noheader.idle.txt")
|
|
NVIDIA_BUSY_4GAPS = """ 0
|
|
95
|
|
88
|
|
72
|
|
"""
|
|
NVIDIA_BUSY_SINGLE = """ 95
|
|
"""
|
|
NVIDIA_NONE = ""
|
|
AMD_SMII_JSON = _load_fixture("amd-smi-monitor--json.txt")
|
|
AMD_SMII_GFX_0 = '[{"gpu":0,"gfx":{"value":0,"unit":"%"}}]'
|
|
AMD_SMII_GFX_80 = '[{"gpu":0,"gfx":{"value":80,"unit":"%"}}]'
|
|
WHO_WITH_USERS = _load_fixture("who.with-users.txt")
|
|
WHO_EMPTY = ""
|
|
|
|
MPSTAT_HIGH = """Linux 6.17.11-200.fc42.x86_64 (gpu-01) 06/08/26 _x86_64_ (12 CPU)
|
|
|
|
21:34:58 CPU %usr %nice %sys %iowait %irq %soft %steal %guest %gnice %idle
|
|
21:34:59 all 85.30 0.00 8.20 0.50 0.00 0.10 0.00 0.00 0.00 5.90
|
|
Average: all 85.30 0.00 8.20 0.50 0.00 0.10 0.00 0.00 0.00 5.90
|
|
"""
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestFreshState(unittest.TestCase):
|
|
|
|
def test_returns_defaults(self):
|
|
from auto_suspend import fresh_state
|
|
state = fresh_state()
|
|
self.assertEqual(state["idle_counter"], 0)
|
|
self.assertEqual(state["gpu_idle_counter"], 0)
|
|
self.assertEqual(state["sample_count"], 0)
|
|
self.assertIsNone(state["cpu_idle_n"])
|
|
self.assertIsNone(state["cpu_idle_n1"])
|
|
self.assertIsNone(state["cpu_avg"])
|
|
|
|
|
|
class TestLoadState(unittest.TestCase):
|
|
|
|
def test_missing_file(self):
|
|
from auto_suspend import load_state
|
|
logger = MagicMock()
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
state = load_state(tmpdir, logger)
|
|
self.assertEqual(state["sample_count"], 0)
|
|
|
|
def test_load_valid_state(self):
|
|
from auto_suspend import load_state
|
|
logger = MagicMock()
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
state_path = Path(tmpdir) / "state.json"
|
|
state_path.write_text(json.dumps({"idle_counter": 3, "sample_count": 5}))
|
|
state = load_state(tmpdir, logger)
|
|
self.assertEqual(state["idle_counter"], 3)
|
|
self.assertEqual(state["sample_count"], 5)
|
|
|
|
def test_load_invalid_json(self):
|
|
from auto_suspend import load_state
|
|
logger = MagicMock()
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
state_path = Path(tmpdir) / "state.json"
|
|
state_path.write_text("{bad json}")
|
|
state = load_state(tmpdir, logger)
|
|
logger.warning.assert_called()
|
|
self.assertEqual(state["sample_count"], 0)
|
|
|
|
def test_missing_keys_merged(self):
|
|
from auto_suspend import load_state
|
|
logger = MagicMock()
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
state_path = Path(tmpdir) / "state.json"
|
|
state_path.write_text(json.dumps({"idle_counter": 1}))
|
|
state = load_state(tmpdir, logger)
|
|
self.assertEqual(state["sample_count"], 0)
|
|
self.assertEqual(state["cpu_avg"], None)
|
|
|
|
|
|
class TestSaveState(unittest.TestCase):
|
|
|
|
def test_atomic_write(self):
|
|
from auto_suspend import save_state
|
|
logger = MagicMock()
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
save_state(tmpdir, {"sample_count": 5, "idle_counter": 2}, logger)
|
|
state_path = Path(tmpdir) / "state.json"
|
|
self.assertTrue(state_path.exists())
|
|
data = json.load(open(state_path))
|
|
self.assertEqual(data["sample_count"], 5)
|
|
|
|
def test_creates_parent(self):
|
|
from auto_suspend import save_state
|
|
logger = MagicMock()
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
nested = Path(tmpdir) / "a" / "b"
|
|
save_state(str(nested), {"sample_count": 1, "idle_counter": 0}, logger)
|
|
self.assertTrue((nested / "state.json").exists())
|
|
|
|
def test_no_tmp_after_save(self):
|
|
from auto_suspend import save_state
|
|
logger = MagicMock()
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
save_state(tmpdir, {"sample_count": 1, "idle_counter": 0}, logger)
|
|
tmpfiles = [f for f in os.listdir(tmpdir) if f.startswith(".state_")]
|
|
self.assertEqual(len(tmpfiles), 0)
|
|
|
|
|
|
class TestMeasureCpu(unittest.TestCase):
|
|
|
|
def test_idle(self):
|
|
from auto_suspend import measure_cpu
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(MPSTAT_IDLE)
|
|
result = measure_cpu(logger)
|
|
self.assertAlmostEqual(result, 99.58, places=1)
|
|
|
|
def test_high_cpu(self):
|
|
from auto_suspend import measure_cpu
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(MPSTAT_HIGH)
|
|
result = measure_cpu(logger)
|
|
self.assertAlmostEqual(result, 5.9, places=1)
|
|
|
|
def test_returncode_nonzero(self):
|
|
from auto_suspend import measure_cpu
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(stdout="", returncode=1, stderr="fail")
|
|
result = measure_cpu(logger)
|
|
self.assertIsNone(result)
|
|
logger.warning.assert_called()
|
|
|
|
def test_timeout(self):
|
|
from auto_suspend import measure_cpu
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.side_effect = subprocess.TimeoutExpired(cmd=["mpstat", "1", "1"], timeout=15)
|
|
result = measure_cpu(logger)
|
|
self.assertIsNone(result)
|
|
logger.warning.assert_called_with("mpstat timed out")
|
|
|
|
def test_portuguese_locale(self):
|
|
"""Verify mpstat with C locale (LC_ALL=C) parses correctly.
|
|
|
|
The measure_cpu function forces LC_ALL=C so mpstat always outputs
|
|
in English regardless of system locale.
|
|
"""
|
|
from auto_suspend import measure_cpu
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(MPSTAT_IDLE)
|
|
result = measure_cpu(logger)
|
|
# Verify subprocess was called with LC_ALL=C
|
|
call_kwargs = run.call_args
|
|
self.assertEqual(call_kwargs[1]["env"]["LC_ALL"], "C")
|
|
self.assertAlmostEqual(result, 99.58, places=1)
|
|
|
|
|
|
class TestMeasureGpuNvidia(unittest.TestCase):
|
|
|
|
def test_idle(self):
|
|
from auto_suspend import measure_gpu_nvidia
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(NVIDIA_IDLE)
|
|
result = measure_gpu_nvidia(logger)
|
|
self.assertAlmostEqual(result, 0.0, places=1)
|
|
|
|
def test_busy_single(self):
|
|
from auto_suspend import measure_gpu_nvidia
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(NVIDIA_BUSY_SINGLE)
|
|
result = measure_gpu_nvidia(logger)
|
|
self.assertAlmostEqual(result, 95.0, places=1)
|
|
|
|
def test_multi_gpu_max(self):
|
|
from auto_suspend import measure_gpu_nvidia
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(NVIDIA_BUSY_4GAPS)
|
|
result = measure_gpu_nvidia(logger)
|
|
self.assertAlmostEqual(result, 95.0, places=1)
|
|
|
|
def test_file_not_found(self):
|
|
from auto_suspend import measure_gpu_nvidia
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.side_effect = FileNotFoundError()
|
|
result = measure_gpu_nvidia(logger)
|
|
self.assertIsNone(result)
|
|
|
|
def test_timeout(self):
|
|
from auto_suspend import measure_gpu_nvidia
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.side_effect = subprocess.TimeoutExpired(cmd=["nvidia-smi"], timeout=15)
|
|
result = measure_gpu_nvidia(logger)
|
|
self.assertIsNone(result)
|
|
logger.warning.assert_called_with("nvidia-smi timed out")
|
|
|
|
def test_returncode_nonzero(self):
|
|
from auto_suspend import measure_gpu_nvidia
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(returncode=1)
|
|
result = measure_gpu_nvidia(logger)
|
|
self.assertIsNone(result)
|
|
|
|
|
|
class TestMeasureGpuAmd(unittest.TestCase):
|
|
|
|
def test_busy(self):
|
|
from auto_suspend import measure_gpu_amd
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(AMD_SMII_JSON)
|
|
result = measure_gpu_amd(logger)
|
|
self.assertAlmostEqual(result, 100.0, places=1)
|
|
|
|
def test_idle_gfx0(self):
|
|
from auto_suspend import measure_gpu_amd
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(AMD_SMII_GFX_0)
|
|
result = measure_gpu_amd(logger)
|
|
self.assertAlmostEqual(result, 0.0, places=1)
|
|
|
|
def test_gfx80(self):
|
|
from auto_suspend import measure_gpu_amd
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(AMD_SMII_GFX_80)
|
|
result = measure_gpu_amd(logger)
|
|
self.assertAlmostEqual(result, 80.0, places=1)
|
|
|
|
def test_file_not_found(self):
|
|
from auto_suspend import measure_gpu_amd
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.side_effect = FileNotFoundError()
|
|
result = measure_gpu_amd(logger)
|
|
self.assertIsNone(result)
|
|
|
|
def test_short_output(self):
|
|
from auto_suspend import measure_gpu_amd
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result("# header only\n")
|
|
result = measure_gpu_amd(logger)
|
|
self.assertIsNone(result)
|
|
|
|
def test_empty_array(self):
|
|
from auto_suspend import measure_gpu_amd
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result("[]")
|
|
result = measure_gpu_amd(logger)
|
|
self.assertIsNone(result)
|
|
|
|
def test_returncode_nonzero(self):
|
|
from auto_suspend import measure_gpu_amd
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(returncode=1)
|
|
result = measure_gpu_amd(logger)
|
|
self.assertIsNone(result)
|
|
|
|
|
|
class TestGetActiveUsers(unittest.TestCase):
|
|
|
|
def test_no_users(self):
|
|
from auto_suspend import get_active_users
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(WHO_EMPTY)
|
|
result = get_active_users(logger)
|
|
self.assertFalse(result)
|
|
|
|
def test_with_users(self):
|
|
from auto_suspend import get_active_users
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.return_value = _make_mock_result(WHO_WITH_USERS)
|
|
result = get_active_users(logger)
|
|
self.assertTrue(result)
|
|
|
|
def test_timeout(self):
|
|
from auto_suspend import get_active_users
|
|
logger = MagicMock()
|
|
with patch("auto_suspend.subprocess.run") as run:
|
|
run.side_effect = subprocess.TimeoutExpired(cmd=["who"], timeout=5)
|
|
result = get_active_users(logger)
|
|
self.assertTrue(result) # conservative: assume user present
|
|
|
|
|
|
class TestUpdateAverages(unittest.TestCase):
|
|
|
|
def test_first_sample(self):
|
|
from auto_suspend import fresh_state, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
new_state = update_averages(state, cpu_n=95.0, gpu_n=2.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(new_state["sample_count"], 1)
|
|
self.assertAlmostEqual(new_state["cpu_avg"], 95.0)
|
|
self.assertEqual(new_state["gpu_idle_counter"], 1) # idle → +1
|
|
self.assertEqual(new_state["cpu_idle_n1"], None)
|
|
|
|
def test_ema_update_cpu_only(self):
|
|
"""CPU EMA updates, GPU idle counter increments."""
|
|
from auto_suspend import fresh_state, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
state = update_averages(state, cpu_n=90.0, gpu_n=1.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
state = update_averages(state, cpu_n=95.0, gpu_n=2.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
# EMA = 0.3 * 95 + 0.7 * 90 = 91.5
|
|
self.assertAlmostEqual(state["cpu_avg"], 91.5)
|
|
# GPU idle both cycles → counter = 2
|
|
self.assertEqual(state["gpu_idle_counter"], 2)
|
|
self.assertEqual(state["sample_count"], 2)
|
|
|
|
def test_gpu_busy_resets_counter(self):
|
|
"""GPU above threshold resets idle counter to 0."""
|
|
from auto_suspend import fresh_state, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
# Cycle 1: idle GPU → counter = 1
|
|
state = update_averages(state, cpu_n=90.0, gpu_n=1.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(state["gpu_idle_counter"], 1)
|
|
# Cycle 2: busy GPU → counter resets to 0
|
|
state = update_averages(state, cpu_n=90.0, gpu_n=50.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(state["gpu_idle_counter"], 0)
|
|
# Cycle 3: idle GPU → counter = 1
|
|
state = update_averages(state, cpu_n=90.0, gpu_n=1.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(state["gpu_idle_counter"], 1)
|
|
|
|
def test_gpu_at_threshold_is_idle(self):
|
|
"""GPU exactly at threshold counts as idle (strictly greater = busy)."""
|
|
from auto_suspend import fresh_state, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
# GPU at exactly 5.0 with threshold 5.0 → idle (not > threshold)
|
|
state = update_averages(state, cpu_n=90.0, gpu_n=5.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(state["gpu_idle_counter"], 1)
|
|
# GPU at 5.1 → busy
|
|
state = update_averages(state, cpu_n=90.0, gpu_n=5.1, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(state["gpu_idle_counter"], 0)
|
|
|
|
def test_gpu_none_is_idle(self):
|
|
"""None GPU (no GPU) counts as idle."""
|
|
from auto_suspend import fresh_state, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
state = update_averages(state, cpu_n=90.0, gpu_n=None, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(state["gpu_idle_counter"], 1)
|
|
|
|
def test_shift_n_to_n1(self):
|
|
from auto_suspend import fresh_state, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
state = update_averages(state, cpu_n=80.0, gpu_n=50.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
state = update_averages(state, cpu_n=85.0, gpu_n=30.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(state["cpu_idle_n"], 85.0)
|
|
self.assertEqual(state["cpu_idle_n1"], 80.0)
|
|
|
|
def test_none_cpu_preserves_avg(self):
|
|
from auto_suspend import fresh_state, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
state = update_averages(state, cpu_n=90.0, gpu_n=5.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
state = update_averages(state, cpu_n=None, gpu_n=None, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertAlmostEqual(state["cpu_avg"], 90.0)
|
|
self.assertEqual(state["sample_count"], 2)
|
|
|
|
def test_gpu_idle_counter_survives_cpu_none(self):
|
|
"""GPU counter increments even when CPU measurement is None."""
|
|
from auto_suspend import fresh_state, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
state = update_averages(state, cpu_n=90.0, gpu_n=1.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
state = update_averages(state, cpu_n=None, gpu_n=0.5, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(state["gpu_idle_counter"], 2)
|
|
self.assertAlmostEqual(state["cpu_avg"], 90.0)
|
|
|
|
def test_consecutive_idle_then_spike(self):
|
|
"""
|
|
Simulate the real data pattern: idle GPU with periodic 100% spikes.
|
|
|
|
Each spike resets the counter. This is the key scenario that the
|
|
old EMA approach handled poorly (spikes lingered in the average).
|
|
"""
|
|
from auto_suspend import fresh_state, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
|
|
# 3 idle cycles → counter = 3
|
|
for _ in range(3):
|
|
state = update_averages(state, cpu_n=99.0, gpu_n=1.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(state["gpu_idle_counter"], 3)
|
|
|
|
# 1 spike → counter resets to 0
|
|
state = update_averages(state, cpu_n=99.0, gpu_n=100.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(state["gpu_idle_counter"], 0)
|
|
|
|
# 3 idle cycles after spike → counter = 3
|
|
for _ in range(3):
|
|
state = update_averages(state, cpu_n=99.0, gpu_n=1.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(state["gpu_idle_counter"], 3)
|
|
|
|
def test_ema_cpu_convergence(self):
|
|
"""
|
|
Verify CPU EMA converges to the steady-state value.
|
|
|
|
With alpha=0.3 and 100 identical samples, the average should equal
|
|
the sample value (since EMA_new = 0.3*x + 0.7*x = x).
|
|
"""
|
|
from auto_suspend import fresh_state, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
|
|
cpu_idle = 97.0
|
|
for _ in range(50):
|
|
state = update_averages(state, cpu_n=cpu_idle, gpu_n=1.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
|
|
self.assertAlmostEqual(state["cpu_avg"], cpu_idle, places=2)
|
|
|
|
|
|
class TestEvaluate(unittest.TestCase):
|
|
|
|
def test_idle_system(self):
|
|
from auto_suspend import fresh_state, update_averages, evaluate
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
for _ in range(3):
|
|
state = update_averages(state, cpu_n=95.0, gpu_n=1.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertTrue(evaluate(state, has_users=False, gpu_idle_counter=3, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
|
|
def test_warmup_skips(self):
|
|
from auto_suspend import fresh_state, evaluate
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
self.assertFalse(evaluate(state, has_users=False, gpu_idle_counter=0, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
|
|
def test_users_logged_in(self):
|
|
from auto_suspend import fresh_state, evaluate, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
for _ in range(3):
|
|
state = update_averages(state, cpu_n=95.0, gpu_n=1.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertFalse(evaluate(state, has_users=True, gpu_idle_counter=3, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
|
|
def test_cpu_not_idle(self):
|
|
from auto_suspend import fresh_state, evaluate, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
for _ in range(3):
|
|
state = update_averages(state, cpu_n=40.0, gpu_n=1.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertFalse(evaluate(state, has_users=False, gpu_idle_counter=3, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
|
|
def test_gpu_busy_resets_evaluation(self):
|
|
"""GPU busy this cycle (counter=0) blocks evaluation even if CPU is idle."""
|
|
from auto_suspend import fresh_state, update_averages, evaluate
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
for _ in range(3):
|
|
state = update_averages(state, cpu_n=95.0, gpu_n=1.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
# Force GPU busy by resetting counter
|
|
self.assertFalse(evaluate(state, has_users=False, gpu_idle_counter=0, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
|
|
def test_gpu_none_is_idle(self):
|
|
from auto_suspend import fresh_state, evaluate, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
for _ in range(3):
|
|
state = update_averages(state, cpu_n=95.0, gpu_n=None, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertTrue(evaluate(state, has_users=False, gpu_idle_counter=3, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
|
|
def test_at_threshold_cpu_below(self):
|
|
from auto_suspend import fresh_state, update_averages, evaluate
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
for _ in range(3):
|
|
state = update_averages(state, cpu_n=90.0, gpu_n=1.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertFalse(evaluate(state, has_users=False, gpu_idle_counter=3, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
|
|
def test_gpu_at_threshold_is_idle(self):
|
|
"""GPU at exactly threshold should NOT block evaluation."""
|
|
from auto_suspend import fresh_state, update_averages, evaluate
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
for _ in range(3):
|
|
state = update_averages(state, cpu_n=95.0, gpu_n=5.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertTrue(evaluate(state, has_users=False, gpu_idle_counter=3, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
|
|
def test_gpu_above_threshold_blocks(self):
|
|
"""GPU above threshold should block evaluation."""
|
|
from auto_suspend import fresh_state, update_averages, evaluate
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
state = update_averages(state, cpu_n=95.0, gpu_n=50.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertFalse(evaluate(state, has_users=False, gpu_idle_counter=0, idle_threshold=90.0, gpu_threshold=5.0, min_samples=1, logger=logger))
|
|
|
|
def test_custom_thresholds(self):
|
|
from auto_suspend import fresh_state, update_averages, evaluate
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
for _ in range(3):
|
|
state = update_averages(state, cpu_n=95.0, gpu_n=3.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertTrue(evaluate(state, has_users=False, gpu_idle_counter=3, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
self.assertFalse(evaluate(state, has_users=False, gpu_idle_counter=3, idle_threshold=95.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
|
|
def test_gpu_busy_during_warmup(self):
|
|
"""GPU busy during warmup: counter=0 but still in warmup."""
|
|
from auto_suspend import fresh_state, evaluate, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
# Only 1 sample, counter=0 because GPU was busy
|
|
state = update_averages(state, cpu_n=95.0, gpu_n=100.0, gpu_threshold=5.0, alpha=0.3, logger=logger)
|
|
self.assertFalse(evaluate(state, has_users=False, gpu_idle_counter=0, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
|
|
|
|
class TestGetWhyNotIdle(unittest.TestCase):
|
|
|
|
def test_users(self):
|
|
from auto_suspend import get_why_not_idle
|
|
state = {"sample_count": 5, "cpu_avg": 95.0, "gpu_idle_counter": 3}
|
|
reason = get_why_not_idle(state, has_users=True, logger=MagicMock())
|
|
self.assertIn("users logged in", reason)
|
|
|
|
def test_cpu_low(self):
|
|
from auto_suspend import get_why_not_idle
|
|
state = {"sample_count": 5, "cpu_avg": 40.0, "gpu_idle_counter": 3}
|
|
reason = get_why_not_idle(state, has_users=False, logger=MagicMock())
|
|
self.assertIn("CPU idle avg", reason)
|
|
|
|
def test_gpu_busy(self):
|
|
from auto_suspend import get_why_not_idle
|
|
state = {"sample_count": 5, "cpu_avg": 95.0, "gpu_idle_counter": 0}
|
|
reason = get_why_not_idle(state, has_users=False, gpu_idle_counter=0, logger=MagicMock())
|
|
self.assertIn("GPU busy", reason)
|
|
|
|
def test_gpu_idle_no_reason(self):
|
|
"""GPU idle counter > 0 should not add a reason."""
|
|
from auto_suspend import get_why_not_idle
|
|
state = {"sample_count": 5, "cpu_avg": 95.0, "gpu_idle_counter": 3}
|
|
reason = get_why_not_idle(state, has_users=False, gpu_idle_counter=3, logger=MagicMock())
|
|
self.assertNotIn("GPU busy", reason)
|
|
|
|
def test_warming_up(self):
|
|
from auto_suspend import get_why_not_idle
|
|
state = {"sample_count": 2, "cpu_avg": None, "gpu_idle_counter": 0}
|
|
reason = get_why_not_idle(state, has_users=False, gpu_idle_counter=0, logger=MagicMock())
|
|
self.assertIn("warming up", reason)
|
|
|
|
def test_multiple_reasons(self):
|
|
from auto_suspend import get_why_not_idle
|
|
state = {"sample_count": 5, "cpu_avg": 40.0, "gpu_idle_counter": 0}
|
|
reason = get_why_not_idle(state, has_users=True, gpu_idle_counter=0, logger=MagicMock())
|
|
self.assertIn("users logged in", reason)
|
|
self.assertIn("CPU idle avg", reason)
|
|
self.assertIn("GPU busy", reason)
|
|
|
|
|
|
class TestSetupLogging(unittest.TestCase):
|
|
|
|
def test_returns_logger(self):
|
|
from auto_suspend import setup_logging
|
|
logger = setup_logging("/tmp/_test_suspend.log", debug=False)
|
|
self.assertEqual(logger.name, "auto_suspend")
|
|
self.assertEqual(len(logger.handlers), 2) # file + stderr
|
|
|
|
|
|
class TestSignalHandler(unittest.TestCase):
|
|
|
|
def test_returns_zero(self):
|
|
from auto_suspend import signal_handler
|
|
with self.assertRaises(SystemExit) as ctx:
|
|
signal_handler(signal.SIGTERM, None)
|
|
self.assertEqual(ctx.exception.code, 0)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|