alexandre.pires
98b0f215aa
- Introduced fixture files for AMD and NVIDIA GPU monitoring outputs, CPU usage statistics, and user sessions. - Created a comprehensive unit test suite for the auto_suspend module, covering state management, CPU and GPU measurement, user activity detection, and evaluation logic. - Updated Ansible tasks to install Python instead of bc, create necessary directories and log files, and ensure proper SELinux context for the auto suspend script. - Modified the systemd service and timer configurations to improve the auto suspend functionality, including command-line arguments for the Python script.
504 lines
20 KiB
Python
504 lines
20 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_GFX = _load_fixture("amd-smi-monitor--csv.txt")
|
|
AMD_SMII_GFX_0 = """gpu,power_usage,hotspot_temperature,memory_temperature,gfx,gfx_clock,mem,mem_clock,encoder,decoder,vclock,dclock,single_bit_ecc,double_bit_ecc,pcie_replay,vram_used,vram_total,pcie_bw,pviol,tviol,phot_tviol,vr_tviol,hbm_tviol
|
|
0,20,52,62,0,1200,0,96,N/A,0.0,25,25,0,0,N/A,11928,16334,N/A,N/A,N/A,N/A,N/A,N/A
|
|
"""
|
|
AMD_SMII_GFX_80 = """gpu,power_usage,hotspot_temperature,memory_temperature,gfx,gfx_clock,mem,mem_clock,encoder,decoder,vclock,dclock,single_bit_ecc,double_bit_ecc,pcie_replay,vram_used,vram_total,pcie_bw,pviol,tviol,phot_tviol,vr_tviol,hbm_tviol
|
|
0,180,78,82,80,1800,90,200,N/A,45.0,25,25,0,0,N/A,14000,16334,N/A,N/A,N/A,N/A,N/A,N/A
|
|
"""
|
|
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
|
|
"""
|
|
|
|
AMD_SMII_ONLY_HEADER = """gpu,power_usage,hotspot_temperature,memory_temperature,gfx
|
|
0,20,52,62,0
|
|
"""
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 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["sample_count"], 0)
|
|
self.assertIsNone(state["cpu_idle_n"])
|
|
self.assertIsNone(state["cpu_idle_n1"])
|
|
self.assertIsNone(state["gpu_util_n"])
|
|
self.assertIsNone(state["gpu_util_n1"])
|
|
self.assertIsNone(state["cpu_avg"])
|
|
self.assertIsNone(state["gpu_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")
|
|
|
|
|
|
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_GFX)
|
|
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_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, alpha=0.3, logger=logger)
|
|
self.assertEqual(new_state["sample_count"], 1)
|
|
self.assertAlmostEqual(new_state["cpu_avg"], 95.0)
|
|
self.assertAlmostEqual(new_state["gpu_avg"], 2.0)
|
|
self.assertEqual(new_state["cpu_idle_n1"], None)
|
|
self.assertEqual(new_state["gpu_util_n1"], None)
|
|
|
|
def test_ema_update(self):
|
|
from auto_suspend import fresh_state, update_averages
|
|
logger = MagicMock()
|
|
state = fresh_state()
|
|
state = update_averages(state, cpu_n=90.0, gpu_n=10.0, alpha=0.3, logger=logger)
|
|
state = update_averages(state, cpu_n=95.0, gpu_n=5.0, alpha=0.3, logger=logger)
|
|
# EMA = 0.3 * 95 + 0.7 * 90 = 91.5
|
|
self.assertAlmostEqual(state["cpu_avg"], 91.5)
|
|
# EMA = 0.3 * 5 + 0.7 * 10 = 8.5
|
|
self.assertAlmostEqual(state["gpu_avg"], 8.5)
|
|
self.assertEqual(state["sample_count"], 2)
|
|
|
|
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, alpha=0.3, logger=logger)
|
|
state = update_averages(state, cpu_n=85.0, gpu_n=30.0, alpha=0.3, logger=logger)
|
|
self.assertEqual(state["cpu_idle_n"], 85.0)
|
|
self.assertEqual(state["cpu_idle_n1"], 80.0)
|
|
self.assertEqual(state["gpu_util_n"], 30.0)
|
|
self.assertEqual(state["gpu_util_n1"], 50.0)
|
|
|
|
def test_none_measurements_preserve_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, alpha=0.3, logger=logger)
|
|
state = update_averages(state, cpu_n=None, gpu_n=None, alpha=0.3, logger=logger)
|
|
self.assertAlmostEqual(state["cpu_avg"], 90.0)
|
|
self.assertAlmostEqual(state["gpu_avg"], 5.0)
|
|
self.assertEqual(state["sample_count"], 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, alpha=0.3, logger=logger)
|
|
self.assertTrue(evaluate(state, has_users=False, 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, 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, alpha=0.3, logger=logger)
|
|
self.assertFalse(evaluate(state, has_users=True, 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, alpha=0.3, logger=logger)
|
|
self.assertFalse(evaluate(state, has_users=False, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
|
|
def test_gpu_busy(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=50.0, alpha=0.3, logger=logger)
|
|
self.assertFalse(evaluate(state, has_users=False, 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, alpha=0.3, logger=logger)
|
|
self.assertTrue(evaluate(state, has_users=False, 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, alpha=0.3, logger=logger)
|
|
self.assertFalse(evaluate(state, has_users=False, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
|
|
def test_at_threshold_gpu_above(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=5.0, alpha=0.3, logger=logger)
|
|
self.assertFalse(evaluate(state, has_users=False, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, 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, alpha=0.3, logger=logger)
|
|
self.assertTrue(evaluate(state, has_users=False, idle_threshold=90.0, gpu_threshold=5.0, min_samples=3, logger=logger))
|
|
self.assertFalse(evaluate(state, has_users=False, idle_threshold=95.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_avg": 1.0}
|
|
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_avg": 1.0}
|
|
reason = get_why_not_idle(state, has_users=False, logger=MagicMock())
|
|
self.assertIn("CPU idle avg", reason)
|
|
|
|
def test_gpu_high(self):
|
|
from auto_suspend import get_why_not_idle
|
|
state = {"sample_count": 5, "cpu_avg": 95.0, "gpu_avg": 50.0}
|
|
reason = get_why_not_idle(state, has_users=False, logger=MagicMock())
|
|
self.assertIn("GPU util avg", reason)
|
|
|
|
def test_warming_up(self):
|
|
from auto_suspend import get_why_not_idle
|
|
state = {"sample_count": 2, "cpu_avg": None, "gpu_avg": None}
|
|
reason = get_why_not_idle(state, has_users=False, 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_avg": 50.0}
|
|
reason = get_why_not_idle(state, has_users=True, logger=MagicMock())
|
|
self.assertIn("users logged in", reason)
|
|
self.assertIn("CPU idle avg", reason)
|
|
self.assertIn("GPU util avg", 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()
|