@ceralive/modem-control 0.1.0 → 1.0.0

package/src/backend/uhubctl-power-hook.ts

@@ -0,0 +1,377 @@
+// The `usb-hub-port-cycle` power hook — recovery ladder rung 4, backed by `uhubctl`.
+//
+// This is the FIRST real `PowerHook` implementation. It cuts VBUS on one port of a
+// per-port-power-switching (PPPS) USB hub, waits for the modem to come back on the
+// SAME physical topology path, and reports `applied` only when it actually did.
+//
+// FOUR safety properties, in the order they bite:
+//
+//   1. CONFIG-MAPPED, NEVER DISCOVERED. A stable key is power-cyclable only if an
+//      operator wrote it into an explicitly-pathed config file (`readUhubctlPowerConfig`
+//      takes the path as an argument — there is no default path, no search, no probe).
+//      An unmapped key returns `unsupported` and touches nothing. Guessing which hub
+//      port a modem is on and then cutting its power is exactly the failure mode that
+//      would black out an unrelated device.
+//   2. ARGV ONLY, ALLOWLISTED. The command is built as an argv array and handed to an
+//      injected runner — there is no shell, no string interpolation, no `sh -c`. Every
+//      generated token is re-checked against `ALLOWED_ARGV` before the runner is
+//      called, so even a config that somehow evaded the schema cannot smuggle a flag.
+//   3. BOUNDED + CANCELLABLE. The runner call is bounded by `commandTimeoutMs`, the
+//      re-enumeration wait by `enumerationTimeoutMs`, and both observe an optional
+//      `AbortSignal`. The worst case is `commandTimeoutMs + enumerationTimeoutMs`;
+//      there is no path that waits forever.
+//   4. SERIALISED PER MODEM. Like every other disruptive op in this backend (see
+//      `mm-mutations.ts`), a cycle runs through the shared per-modem `ModemActor`,
+//      keyed on the STABLE key. Two overlapping cycles on one port would otherwise
+//      interleave a power-on with a power-off and leave the port dark.
+//
+// PROOF OF SUCCESS IS RE-ENUMERATION, NOT EXIT CODE 0. `uhubctl` exiting 0 only means
+// the hub accepted the request. The hook records the modem's `ID_PATH` BEFORE the cut
+// and only reports `applied` once that same `ID_PATH` is observed again — a port that
+// powers back up with nothing on it is a `failed`, reported with expected-vs-observed.
+//
+// -----------------------------------------------------------------------------------
+// CAVEAT — STALE DEVICE FILES ON LINUX KERNELS BEFORE 6.0.
+//
+// uhubctl README, FAQ section `_USB devices are not removed after port power down on
+// Linux_` (github.com/mvp/uhubctl, README.md), verbatim:
+//
+//   "After powering down USB port, udev does not get any event, so it keeps the device
+//    files around. However, trying to access the device files will lead to an IO error.
+//    This is Linux kernel issue and is fixed since uhubctl 2.5.0 for systems with Linux
+//    kernel 6.0 or later. If you are still using Linux 5.x or older, you can use this
+//    workaround for this issue:
+//
+//        sudo uhubctl -a off -l ${location} -p ${port}
+//        sudo udevadm trigger --action=remove /sys/bus/usb/devices/${location}.${port}/
+//
+//    Device file will be removed by udev, but USB device will be still visible in
+//    `lsusb`. Note that path /sys/bus/usb/devices/${location}.${port} will only exist if
+//    device was detected on that port. When you turn power back on, device should
+//    re-enumerate properly (no need to call `udevadm` again)."
+//
+// Why it matters HERE: during the dark window of a cycle, a pre-6.0 kernel leaves the
+// device files in place, so a presence check that asks "does the node still exist?"
+// reports the modem as present when it is electrically gone — and would let this hook
+// declare `applied` off a stale artefact rather than a real re-enumeration.
+//
+// THIS HOOK DOES NOT RUN `udevadm trigger --action=remove` ITSELF, deliberately: it is
+// a privileged host-wide udev mutation whose sysfs path only exists if a device was
+// detected there, and firing it from a recovery rung would make rung 4 mutate state
+// well outside the port it was mapped to. Instead the hook is built so the caveat
+// cannot corrupt its verdict — presence is resolved by the INJECTED
+// `UsbEnumerationPoller`, whose production implementation re-reads udev every call and
+// never caches (see `usb-enumerator.ts`, which re-runs `udevadm info --export-db` per
+// `enumerate()`), and the postcondition compares `ID_PATH`, not a device-node path. A
+// deployment pinned to a pre-6.0 kernel wires the `udevadm trigger --action=remove`
+// step into that poller or into a udev rule — one explicit, auditable place.
+//
+// Hardware note: the README's compatible-hub table lists `0BDA:0411` (Rosonway RSH-A10
+// / RSH-A16, Juiced Systems 6HUB-01) as per-port-power-switching capable — that is the
+// Realtek chipset on this project's bench board. `0bda:5411` is NOT on that list, so a
+// hub reporting that id may need `-f`, which this hook never passes.
+// -----------------------------------------------------------------------------------
+
+import { z } from 'zod';
+import { ModemActor } from './modem-actor';
+import type {
+	PowerCapability,
+	PowerCycleContext,
+	PowerCycleResult,
+	PowerHook,
+	PreferredUsbMode,
+} from './power-contract';
+
+/**
+ * A uhubctl hub location: `<bus>-<port>[.<port>…]` (e.g. `1-1`, `2-1.4`), or a bare
+ * bus number for a root hub. This mirrors the Linux sysfs USB path and is the ONLY
+ * shape accepted — a VID:PID selector or a `--` flag can never parse as one.
+ */
+const HUB_LOCATION = /^[0-9]{1,3}(-[0-9]{1,3}(\.[0-9]{1,3})*)?$/;
+
+/** One mapped modem: which PPPS hub it hangs off, and which port on that hub. */
+export const uhubctlPortMappingSchema = z.strictObject({
+	/** The hub's uhubctl location (`-l`), e.g. `1-1` or `2-1.4`. */
+	hubLocation: z.string().regex(HUB_LOCATION, 'hubLocation must look like `1-1` or `2-1.4`'),
+	/** The 1-based port number on that hub (`-p`). */
+	port: z.number().int().min(1).max(255),
+});
+export type UhubctlPortMapping = z.infer<typeof uhubctlPortMappingSchema>;
+
+/**
+ * The whole config file: a map from STABLE KEY to its hub/port mapping. `.strictObject`
+ * on each entry means a typo'd or smuggled extra field is rejected rather than ignored.
+ */
+export const uhubctlPortMapSchema = z.record(z.string().min(1), uhubctlPortMappingSchema);
+export type UhubctlPortMap = z.infer<typeof uhubctlPortMapSchema>;
+
+/**
+ * Parse config text (JSON) into a validated port map. `path` is used only for the
+ * error message, so a malformed file fails visibly with a named field.
+ */
+export function parseUhubctlPortMap(text: string, path: string): UhubctlPortMap {
+	let raw: unknown;
+	try {
+		raw = JSON.parse(text) as unknown;
+	} catch (error) {
+		throw new Error(`invalid uhubctl port map ${path}: ${describe(error)}`);
+	}
+	const result = uhubctlPortMapSchema.safeParse(raw);
+	if (!result.success) {
+		const issue = result.error.issues[0];
+		const where = issue?.path.join('.') || '(root)';
+		throw new Error(
+			`invalid uhubctl port map ${path}: ${where}: ${issue?.message ?? 'schema mismatch'}`,
+		);
+	}
+	return result.data;
+}
+
+/**
+ * Read + validate a port map from an EXPLICIT path. There is intentionally no default
+ * and no discovery: a caller that cannot name the file gets no power control.
+ */
+export async function readUhubctlPortMap(path: string): Promise<UhubctlPortMap> {
+	return parseUhubctlPortMap(await Bun.file(path).text(), path);
+}
+
+/** The result of one `uhubctl` invocation. */
+export interface UhubctlResult {
+	readonly stdout: string;
+	readonly stderr: string;
+	readonly exitCode: number;
+}
+
+/**
+ * A runner over `uhubctl` argv — structurally the same seam as `NmcliRunner`. Tests
+ * inject a fake; the device injects `SpawnUhubctlRunner`. The hook NEVER spawns
+ * directly, so the argv the tests assert against is byte-for-byte what runs on-device.
+ */
+export interface UhubctlRunner {
+	run(argv: readonly string[]): UhubctlResult | Promise<UhubctlResult>;
+}
+
+/** The device-exact runner: spawns the real `uhubctl` with the argv array verbatim. */
+export class SpawnUhubctlRunner implements UhubctlRunner {
+	async run(argv: readonly string[]): Promise<UhubctlResult> {
+		const proc = Bun.spawn(['uhubctl', ...argv], { stdout: 'pipe', stderr: 'pipe' });
+		const [stdout, stderr, exitCode] = await Promise.all([
+			new Response(proc.stdout).text(),
+			new Response(proc.stderr).text(),
+			proc.exited,
+		]);
+		return { stdout, stderr, exitCode };
+	}
+}
+
+/**
+ * Resolves the modem's current udev `ID_PATH` (its physical topology UID) for a stable
+ * key, or `undefined` when nothing is enumerated there. Injected so tests need no
+ * hardware; the production implementation MUST re-read udev/sysfs every call (see the
+ * pre-6.0 stale-devfile caveat at the top of this file).
+ */
+export interface UsbEnumerationPoller {
+	idPathFor(stableKey: string): string | undefined | Promise<string | undefined>;
+}
+
+const DEFAULT_ENUMERATION_TIMEOUT_MS = 30_000;
+const DEFAULT_COMMAND_TIMEOUT_MS = 15_000;
+const DEFAULT_POLL_INTERVAL_MS = 250;
+/** `uhubctl -d` — seconds the port stays dark before it is powered back on. */
+const DEFAULT_POWER_OFF_DELAY_SECONDS = 3;
+
+/** Construction dependencies. Everything that touches the system is injectable. */
+export interface UhubctlPowerHookDeps {
+	/** The validated stable-key → hub/port map (see `readUhubctlPortMap`). */
+	readonly ports: UhubctlPortMap;
+	readonly runner: UhubctlRunner;
+	readonly poller: UsbEnumerationPoller;
+	/** Shared per-modem serialisation. Defaults to a private actor. */
+	readonly actor?: ModemActor;
+	readonly enumerationTimeoutMs?: number;
+	readonly commandTimeoutMs?: number;
+	readonly pollIntervalMs?: number;
+	readonly powerOffDelaySeconds?: number;
+	readonly preferredUsbMode?: PreferredUsbMode;
+	/** Cancels an in-flight cycle — the hook resolves `failed`, it never hangs. */
+	readonly signal?: AbortSignal;
+	readonly sleep?: (ms: number) => Promise<void>;
+	readonly now?: () => number;
+}
+
+/**
+ * Every argv token this hook is permitted to emit. The flags are literals; the two
+ * value slots are re-validated against the same shapes the schema enforced. Anything
+ * else is a bug in this file and fails closed before the runner is called.
+ */
+const ALLOWED_ARGV: readonly RegExp[] = [
+	/^-l$/,
+	/^-p$/,
+	/^-a$/,
+	/^-d$/,
+	/^cycle$/,
+	HUB_LOCATION,
+	/^[0-9]{1,3}$/,
+];
+
+/** Build the `uhubctl` argv for one mapping. Pure + exported so tests can assert it. */
+export function uhubctlCycleArgv(
+	mapping: UhubctlPortMapping,
+	powerOffDelaySeconds: number,
+): readonly string[] {
+	const argv = [
+		'-l',
+		mapping.hubLocation,
+		'-p',
+		String(mapping.port),
+		'-a',
+		'cycle',
+		'-d',
+		String(powerOffDelaySeconds),
+	];
+	for (const token of argv) {
+		if (!ALLOWED_ARGV.some((allowed) => allowed.test(token))) {
+			throw new Error(`refusing to run uhubctl: argv token '${token}' is not allowlisted`);
+		}
+	}
+	return argv;
+}
+
+/** The `usb-hub-port-cycle` power hook. One instance serves every mapped modem. */
+export function createUhubctlPowerHook(deps: UhubctlPowerHookDeps): PowerHook {
+	const enumerationTimeoutMs = deps.enumerationTimeoutMs ?? DEFAULT_ENUMERATION_TIMEOUT_MS;
+	const commandTimeoutMs = deps.commandTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
+	const pollIntervalMs = deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+	const powerOffDelaySeconds = deps.powerOffDelaySeconds ?? DEFAULT_POWER_OFF_DELAY_SECONDS;
+	const actor = deps.actor ?? new ModemActor();
+	const now = deps.now ?? Date.now;
+	const sleep = deps.sleep ?? defaultSleep;
+
+	const capability: PowerCapability = {
+		power: 'usb-hub-port-cycle',
+		usbReset: true,
+		enumerationTimeoutMs,
+		...(deps.preferredUsbMode !== undefined ? { preferredUsbMode: deps.preferredUsbMode } : {}),
+	};
+
+	const cancelled = (): PowerCycleResult | undefined =>
+		deps.signal?.aborted === true
+			? { status: 'failed', reason: 'power cycle cancelled by the caller' }
+			: undefined;
+
+	async function awaitReenumeration(
+		stableKey: string,
+		expected: string | undefined,
+	): Promise<PowerCycleResult> {
+		const deadline = now() + enumerationTimeoutMs;
+		let observed: string | undefined;
+		while (now() < deadline) {
+			const abort = cancelled();
+			if (abort !== undefined) {
+				return abort;
+			}
+			observed = await deps.poller.idPathFor(stableKey);
+			// A port cycle preserves the physical topology, so the SAME ID_PATH must
+			// come back. If nothing was enumerated before the cut there is no path to
+			// compare against — any device re-appearing at that key is the recovery.
+			if (observed !== undefined && (expected === undefined || observed === expected)) {
+				return {
+					status: 'applied',
+					reason: `port cycled; modem re-enumerated at ID_PATH '${observed}'`,
+				};
+			}
+			await sleep(pollIntervalMs);
+		}
+		return {
+			status: 'failed',
+			reason:
+				`modem did not re-enumerate within ${enumerationTimeoutMs}ms — expected ID_PATH ` +
+				`${expected === undefined ? '(any device)' : `'${expected}'`}, observed ` +
+				`${observed === undefined ? 'no device' : `'${observed}'`}`,
+		};
+	}
+
+	async function cycleMapped(
+		stableKey: string,
+		mapping: UhubctlPortMapping,
+	): Promise<PowerCycleResult> {
+		// Record the pre-cut topology path — the postcondition compares against it.
+		const expected = await deps.poller.idPathFor(stableKey);
+
+		let argv: readonly string[];
+		try {
+			argv = uhubctlCycleArgv(mapping, powerOffDelaySeconds);
+		} catch (error) {
+			return { status: 'failed', reason: describe(error) };
+		}
+
+		let result: UhubctlResult;
+		try {
+			result = await withTimeout(
+				Promise.resolve(deps.runner.run(argv)),
+				commandTimeoutMs,
+				`uhubctl did not return within ${commandTimeoutMs}ms`,
+			);
+		} catch (error) {
+			return { status: 'failed', reason: `uhubctl ${argv.join(' ')} failed: ${describe(error)}` };
+		}
+		if (result.exitCode !== 0) {
+			return {
+				status: 'failed',
+				reason:
+					`uhubctl ${argv.join(' ')} exited ${result.exitCode}: ` +
+					`${result.stderr.trim() || result.stdout.trim() || '(no output)'}`,
+			};
+		}
+
+		// Exit 0 only means the hub accepted the request — re-enumeration is the proof.
+		return awaitReenumeration(stableKey, expected);
+	}
+
+	return {
+		capability,
+		cycle(context: PowerCycleContext): Promise<PowerCycleResult> {
+			const { stableKey } = context;
+			const mapping = deps.ports[stableKey];
+			if (mapping === undefined) {
+				// Refuse BEFORE the actor and before any I/O: an unmapped key must never
+				// cut power to a port that was never declared to belong to it.
+				return Promise.resolve({
+					status: 'unsupported',
+					reason: `no uhubctl hub/port mapping is configured for stable key '${stableKey}'`,
+				});
+			}
+			const abort = cancelled();
+			if (abort !== undefined) {
+				return Promise.resolve(abort);
+			}
+			// Serialised on the STABLE key, like every other disruptive op (mm-mutations).
+			return actor.run(stableKey, () => cycleMapped(stableKey, mapping));
+		},
+	};
+}
+
+function defaultSleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/** Bound a promise; rejects with `message` if it has not settled in `ms`. */
+async function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T> {
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	try {
+		return await Promise.race([
+			promise,
+			new Promise<never>((_resolve, reject) => {
+				timer = setTimeout(() => reject(new Error(message)), ms);
+			}),
+		]);
+	} finally {
+		if (timer !== undefined) {
+			clearTimeout(timer);
+		}
+	}
+}
+
+function describe(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}

package/src/backend/usage/index.ts

@@ -12,6 +12,29 @@ export {
 } from './accounting';
 export { clampCycleDay, cycleStart, daysInMonth } from './billing-cycle';
 export { readBootId } from './boot-id';
+export {
+	createUsagePolicyFileStore,
+	isValidCycleDay,
+	isValidThresholdBytes,
+	type PersistedUsagePolicy,
+	type PersistedUsagePolicySlot,
+	selectUsagePolicy,
+	USAGE_POLICY_SCHEMA_VERSION,
+	type UsagePolicyFileStoreOptions,
+	type UsagePolicyLogEvent,
+	type UsagePolicyLogger,
+	type UsagePolicyStore,
+} from './policy-store';
+export {
+	getUsagePolicy,
+	type SetUsagePolicyDeps,
+	type SetUsagePolicyRejection,
+	type SetUsagePolicyRequest,
+	type SetUsagePolicyResult,
+	setUsagePolicy,
+	type UsagePolicyApplication,
+	type UsagePolicyTarget,
+} from './policy-write';
 export {
 	type CounterSource,
 	parseProcNetDev,

package/src/backend/usage/policy-store.test.ts

@@ -0,0 +1,164 @@
+// Usage-policy persistence contract — mode 0600 (real fs.stat), fail-soft
+// corruption recovery with METADATA-ONLY logging, and the per-slot selector.
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+	createUsagePolicyFileStore,
+	isValidCycleDay,
+	isValidThresholdBytes,
+	type PersistedUsagePolicy,
+	selectUsagePolicy,
+	USAGE_POLICY_SCHEMA_VERSION,
+	type UsagePolicyLogEvent,
+} from './policy-store';
+
+let dir: string;
+let path: string;
+
+beforeEach(async () => {
+	dir = await mkdtemp(join(tmpdir(), 'usage-policy-'));
+	path = join(dir, 'policy.json');
+});
+
+afterEach(async () => {
+	await rm(dir, { recursive: true, force: true });
+});
+
+const sample: PersistedUsagePolicy = {
+	schemaVersion: USAGE_POLICY_SCHEMA_VERSION,
+	savedAtMs: 1_700_000_000_000,
+	slots: [
+		{ logicalSlotId: 'slot-a', cycleDay: 15, thresholdBytes: 5_000_000_000 },
+		{ logicalSlotId: 'slot-b', cycleDay: 1 },
+		{ logicalSlotId: 'slot-c', thresholdBytes: 0 },
+	],
+};
+
+describe('UsagePolicyStore — versioned round-trip', () => {
+	test('save then load returns identical, schema-versioned state', async () => {
+		const store = createUsagePolicyFileStore({ path });
+		await store.save(sample);
+		expect(await store.load(1)).toEqual(sample);
+	});
+
+	test('an absent file loads as a fresh empty document and writes nothing', async () => {
+		const store = createUsagePolicyFileStore({ path });
+		const loaded = await store.load(4242);
+		expect(loaded).toEqual({
+			schemaVersion: USAGE_POLICY_SCHEMA_VERSION,
+			savedAtMs: 4242,
+			slots: [],
+		});
+		expect(readFile(path, 'utf8')).rejects.toThrow();
+	});
+
+	test('the written file is mode 0600 regardless of umask', async () => {
+		const store = createUsagePolicyFileStore({ path });
+		await store.save(sample);
+		expect((await stat(path)).mode & 0o777).toBe(0o600);
+	});
+});
+
+describe('UsagePolicyStore — fail-soft corruption', () => {
+	test('invalid JSON is replaced by a fresh 0600 file and logged as METADATA ONLY', async () => {
+		const events: UsagePolicyLogEvent[] = [];
+		await writeFile(path, '{"schemaVersion":1,"slots":');
+		const store = createUsagePolicyFileStore({ path, logger: (e) => events.push(e) });
+
+		const loaded = await store.load(7);
+
+		expect(loaded.slots).toEqual([]);
+		expect(events).toHaveLength(1);
+		expect(events[0]?.kind).toBe('corrupt-policy');
+		expect(events[0]?.reason).toContain('invalid-json');
+		expect((await stat(path)).mode & 0o777).toBe(0o600);
+	});
+
+	test.each([
+		[
+			'schemaVersion',
+			JSON.stringify({ ...sample, schemaVersion: 99 }),
+			'schema-mismatch: schemaVersion',
+		],
+		['savedAtMs', JSON.stringify({ ...sample, savedAtMs: 'soon' }), 'schema-mismatch: savedAtMs'],
+		['slots', JSON.stringify({ ...sample, slots: {} }), 'schema-mismatch: slots'],
+		[
+			'logicalSlotId',
+			JSON.stringify({ ...sample, slots: [{ cycleDay: 3 }] }),
+			'schema-mismatch: logicalSlotId',
+		],
+		[
+			'cycleDay',
+			JSON.stringify({ ...sample, slots: [{ logicalSlotId: 'a', cycleDay: 32 }] }),
+			'schema-mismatch: cycleDay',
+		],
+		[
+			'thresholdBytes',
+			JSON.stringify({ ...sample, slots: [{ logicalSlotId: 'a', thresholdBytes: -1 }] }),
+			'schema-mismatch: thresholdBytes',
+		],
+	])('a bad %s is rejected by name and never throws', async (_field, text, reason) => {
+		const events: UsagePolicyLogEvent[] = [];
+		await writeFile(path, text);
+		const store = createUsagePolicyFileStore({ path, logger: (e) => events.push(e) });
+
+		expect((await store.load(9)).slots).toEqual([]);
+		expect(events[0]?.reason).toBe(reason);
+	});
+
+	test('the corruption log carries a byte count and NEVER the file content', async () => {
+		const secretish = JSON.stringify({ schemaVersion: 1, slots: 'iccid-8991101200003204514' });
+		const events: UsagePolicyLogEvent[] = [];
+		await writeFile(path, secretish);
+		const store = createUsagePolicyFileStore({ path, logger: (e) => events.push(e) });
+
+		await store.load(11);
+
+		expect(events[0]?.bytes).toBe(Buffer.byteLength(secretish, 'utf8'));
+		expect(JSON.stringify(events[0])).not.toContain('8991101200003204514');
+	});
+});
+
+describe('selectUsagePolicy', () => {
+	test('returns the slot policy, omitting fields the slot never set', () => {
+		expect(selectUsagePolicy(sample, 'slot-a')).toEqual({
+			cycleDay: 15,
+			thresholdBytes: 5_000_000_000,
+		});
+		expect(selectUsagePolicy(sample, 'slot-b')).toEqual({ cycleDay: 1 });
+		expect(selectUsagePolicy(sample, 'slot-c')).toEqual({ thresholdBytes: 0 });
+	});
+
+	test('an unknown slot answers "no policy set", not a default', () => {
+		expect(selectUsagePolicy(sample, 'nope')).toEqual({});
+	});
+});
+
+describe('validators', () => {
+	test.each([
+		[1, true],
+		[31, true],
+		[15, true],
+		[0, false],
+		[32, false],
+		[1.5, false],
+		[Number.NaN, false],
+		['3', false],
+	])('isValidCycleDay(%p) === %p', (value, expected) => {
+		expect(isValidCycleDay(value)).toBe(expected);
+	});
+
+	test.each([
+		[0, true],
+		[5_000_000_000, true],
+		[-1, false],
+		[1.5, false],
+		[Number.POSITIVE_INFINITY, false],
+		['5', false],
+	])('isValidThresholdBytes(%p) === %p', (value, expected) => {
+		expect(isValidThresholdBytes(value)).toBe(expected);
+	});
+});