Files
claude-config/bin/machine_load/test_machine_load.py
T

96 lines
3.7 KiB
Python

import errno
import fcntl
import os
import pathlib
import sys
import tempfile
import unittest
import unittest.mock
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from machine_load import memory
from machine_load.slots import slot_count
from machine_load import slots
class SlotCount(unittest.TestCase):
def test_one_slot_per_four_cpus_and_never_none(self):
for cpus, slots in ((16, 4), (8, 2), (7, 1), (4, 1), (1, 1), (None, 1)):
with self.subTest(cpus=cpus):
self.assertEqual(slot_count(cpus), slots)
class MemoryShare(unittest.TestCase):
def test_has_room_from_a_quarter_of_memory_available(self):
self.assertFalse(memory.Memory(available=3, total=16).has_room())
self.assertTrue(memory.Memory(available=4, total=16).has_room())
def test_reads_available_and_total_memory_from_meminfo(self):
meminfo = "MemTotal: 16387072 kB\nMemFree: 981236 kB\nMemAvailable: 4096000 kB\n"
self.assertEqual(memory.parsed(meminfo), memory.Memory(available=4096000, total=16387072))
def test_reads_nothing_from_a_meminfo_missing_a_figure_or_holding_a_bad_one(self):
for unread in ("MemTotal: 16 kB\n", "MemTotal: x kB\nMemAvailable: 1 kB\n", ""):
with self.subTest(unread=unread):
self.assertIsNone(memory.parsed(unread))
def test_reads_a_meminfo_file_and_none_where_it_cannot(self):
with tempfile.TemporaryDirectory() as temp:
meminfo = pathlib.Path(temp, "meminfo")
meminfo.write_text("MemTotal: 8 kB\nMemAvailable: 2 kB\n")
self.assertEqual(memory.read_memory(meminfo), memory.Memory(available=2, total=8))
self.assertIsNone(memory.read_memory(pathlib.Path(temp, "gone")))
class SlotShare(unittest.TestCase):
def test_splits_the_three_quarters_a_worker_leaves_evenly_across_the_slots_in_mib(self):
self.assertEqual(memory.Memory(available=0, total=32 * 1024 * 1024).slot_share(4), 6144)
self.assertEqual(memory.Memory(available=0, total=8000000).slot_share(2), 2929)
class SlotFolder(unittest.TestCase):
def test_every_session_shares_the_slots_under_the_users_state_folder(self):
self.assertEqual(slots.slot_folder({}), pathlib.Path.home() / ".local" / "state" / "run-heavy")
self.assertEqual(slots.slot_folder({"XDG_STATE_HOME": "/s"}), pathlib.Path("/s/run-heavy"))
class TakenSlot(unittest.TestCase):
def test_a_lock_that_fails_for_another_reason_than_a_holder_closes_its_file_and_raises(self):
closed = []
with tempfile.TemporaryDirectory() as folder, unittest.mock.patch("fcntl.flock", side_effect=OSError(errno.ENOLCK, "No locks available")), unittest.mock.patch("os.close", side_effect=closed.append):
with self.assertRaises(OSError):
slots.taken_slot(pathlib.Path(folder), 2)
self.assertEqual(len(closed), 1)
self.assertIsInstance(closed[0], int)
os.close(closed[0])
class WaitedSlot(unittest.TestCase):
def test_waits_while_every_slot_is_held_saying_so_once_then_takes_the_freed_one(self):
with tempfile.TemporaryDirectory() as folder:
held = [open(pathlib.Path(folder, f"slot-{slot}"), "a") for slot in range(2)]
for file in held:
fcntl.flock(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
said, slept = [], []
def sleep(seconds):
slept.append(seconds)
if len(slept) == 2:
held[1].close()
slot, fd = slots.waited_slot(pathlib.Path(folder), 2, lambda: said.append(True), sleep)
os.close(fd)
held[0].close()
self.assertEqual((slot, said, slept), (1, [True], [slots.POLL_SECONDS] * 2))
def test_takes_a_free_slot_at_once(self):
with tempfile.TemporaryDirectory() as folder:
slot, fd = slots.waited_slot(pathlib.Path(folder), 2, lambda: self.fail("said it waits"), lambda seconds: self.fail("slept"))
os.close(fd)
self.assertEqual(slot, 0)
if __name__ == "__main__":
unittest.main()