@matterbridge/core 3.7.5-dev-20260419-96eefd1 → 3.7.5-dev-20260421-b7fd269

package/dist/jestutils/jestHelpers.js

@@ -1,644 +0,0 @@
-import { rmSync } from 'node:fs';
-import path from 'node:path';
-import { inspect } from 'node:util';
-import { Environment, Lifecycle, LogFormat as MatterLogFormat, LogLevel as MatterLogLevel } from '@matter/general';
-import { Endpoint, ServerNode, ServerNodeStore } from '@matter/node';
-import { AggregatorEndpoint } from '@matter/node/endpoints';
-import { MdnsService } from '@matter/protocol';
-import { ColorControl } from '@matter/types/clusters/color-control';
-import { DeviceTypeId, VendorId } from '@matter/types/datatype';
-import { MATTER_STORAGE_DIR, NODE_STORAGE_DIR } from '@matterbridge/types';
-import { AnsiLogger, er, rs, UNDERLINE, UNDERLINEOFF } from 'node-ansi-logger';
-import { NodeStorageManager } from 'node-persist-manager';
-import { Matterbridge } from '../matterbridge.js';
-import { bridge } from '../matterbridgeDeviceTypes.js';
-export const originalProcessArgv = Object.freeze([...process.argv]);
-export const originalProcessEnv = Object.freeze({ ...process.env });
-export let loggerLogSpy;
-export let loggerDebugSpy;
-export let loggerInfoSpy;
-export let loggerNoticeSpy;
-export let loggerWarnSpy;
-export let loggerErrorSpy;
-export let loggerFatalSpy;
-export let consoleLogSpy;
-export let consoleDebugSpy;
-export let consoleInfoSpy;
-export let consoleWarnSpy;
-export let consoleErrorSpy;
-export let NAME;
-export let HOMEDIR;
-export let matterbridge;
-export let frontend;
-export let plugins;
-export let devices;
-export let environment;
-export let server;
-export let aggregator;
-export let log;
-export async function setupTest(name, debug = false) {
-    expect(name).toBeDefined();
-    expect(typeof name).toBe('string');
-    expect(name.length).toBeGreaterThanOrEqual(4);
-    NAME = name;
-    HOMEDIR = path.join('.cache', 'jest', name);
-    rmSync(HOMEDIR, { recursive: true, force: true });
-    const { jest } = await import('@jest/globals');
-    loggerDebugSpy = jest.spyOn(AnsiLogger.prototype, 'debug');
-    loggerInfoSpy = jest.spyOn(AnsiLogger.prototype, 'info');
-    loggerNoticeSpy = jest.spyOn(AnsiLogger.prototype, 'notice');
-    loggerWarnSpy = jest.spyOn(AnsiLogger.prototype, 'warn');
-    loggerErrorSpy = jest.spyOn(AnsiLogger.prototype, 'error');
-    loggerFatalSpy = jest.spyOn(AnsiLogger.prototype, 'fatal');
-    if (debug) {
-        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
-        consoleLogSpy = jest.spyOn(console, 'log');
-        consoleDebugSpy = jest.spyOn(console, 'debug');
-        consoleInfoSpy = jest.spyOn(console, 'info');
-        consoleWarnSpy = jest.spyOn(console, 'warn');
-        consoleErrorSpy = jest.spyOn(console, 'error');
-    }
-    else {
-        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log').mockImplementation(() => { });
-        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
-        consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
-        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
-        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-    }
-}
-export async function setDebug(debug) {
-    const { jest } = await import('@jest/globals');
-    if (debug) {
-        loggerLogSpy.mockRestore();
-        consoleLogSpy.mockRestore();
-        consoleDebugSpy.mockRestore();
-        consoleInfoSpy.mockRestore();
-        consoleWarnSpy.mockRestore();
-        consoleErrorSpy.mockRestore();
-        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
-        consoleLogSpy = jest.spyOn(console, 'log');
-        consoleDebugSpy = jest.spyOn(console, 'debug');
-        consoleInfoSpy = jest.spyOn(console, 'info');
-        consoleWarnSpy = jest.spyOn(console, 'warn');
-        consoleErrorSpy = jest.spyOn(console, 'error');
-    }
-    else {
-        loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log').mockImplementation(() => { });
-        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
-        consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
-        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
-        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-    }
-}
-export async function startMatterbridge(bridgeMode = 'bridge', frontendPort = 8283, matterPort = 5540, passcode = 20252026, discriminator = 3840, pluginSize = 0, devicesSize = 0) {
-    process.env['MATTERBRIDGE_START_MATTER_INTERVAL_MS'] = '100';
-    process.env['MATTERBRIDGE_PAUSE_MATTER_INTERVAL_MS'] = '100';
-    process.argv.length = 0;
-    process.argv.push(...originalProcessArgv, '--novirtual', '--debug', '--verbose', '--logger', 'debug', '--matterlogger', 'debug', bridgeMode === '' ? '--test' : '--' + bridgeMode, '--homedir', HOMEDIR, '--frontend', frontendPort.toString(), '--port', matterPort.toString(), '--passcode', passcode.toString(), '--discriminator', discriminator.toString());
-    expect(Matterbridge.instance).toBeUndefined();
-    matterbridge = await Matterbridge.loadInstance(true);
-    expect(matterbridge.environment).toBeDefined();
-    expect(matterbridge.systemCheckTimeout).toBeDefined();
-    expect(matterbridge.checkUpdateTimeout).toBeDefined();
-    expect(matterbridge.checkUpdateInterval).toBeDefined();
-    clearTimeout(matterbridge.systemCheckTimeout);
-    clearTimeout(matterbridge.checkUpdateTimeout);
-    clearInterval(matterbridge.checkUpdateInterval);
-    new MdnsService(matterbridge.environment);
-    expect(matterbridge).toBeDefined();
-    expect(matterbridge.profile).toBeUndefined();
-    expect(matterbridge.bridgeMode).toBe(bridgeMode);
-    frontend = matterbridge.frontend;
-    plugins = matterbridge.plugins;
-    devices = matterbridge.devices;
-    expect(matterbridge.initialized).toBeTruthy();
-    expect(matterbridge.log).toBeDefined();
-    expect(matterbridge.rootDirectory).toBe(path.resolve('./'));
-    expect(matterbridge.homeDirectory).toBe(path.join(HOMEDIR));
-    expect(matterbridge.matterbridgeDirectory).toBe(path.join(HOMEDIR, '.matterbridge'));
-    expect(matterbridge.matterbridgePluginDirectory).toBe(path.join(HOMEDIR, 'Matterbridge'));
-    expect(matterbridge.matterbridgeCertDirectory).toBe(path.join(HOMEDIR, '.mattercert'));
-    expect(plugins).toBeDefined();
-    expect(plugins.size).toBe(pluginSize);
-    expect(devices).toBeDefined();
-    expect(devices.size).toBe(devicesSize);
-    expect(frontend).toBeDefined();
-    expect(frontend.listening).toBeTruthy();
-    expect(frontend.httpServer).toBeDefined();
-    expect(frontend.httpsServer).toBeUndefined();
-    expect(frontend.expressApp).toBeDefined();
-    expect(frontend.webSocketServer).toBeDefined();
-    expect(matterbridge.nodeStorage).toBeDefined();
-    expect(matterbridge.nodeContext).toBeDefined();
-    expect(Environment.default.vars.get('path.root')).toBe(path.join(matterbridge.matterbridgeDirectory, MATTER_STORAGE_DIR));
-    expect(matterbridge.matterStorageService).toBeDefined();
-    expect(matterbridge.matterStorageManager).toBeDefined();
-    expect(matterbridge.matterbridgeContext).toBeDefined();
-    expect(matterbridge.controllerContext).toBeUndefined();
-    if (bridgeMode === 'bridge') {
-        expect(matterbridge.serverNode).toBeDefined();
-        expect(matterbridge.aggregatorNode).toBeDefined();
-    }
-    expect(matterbridge.mdnsInterface).toBe(undefined);
-    expect(matterbridge.port).toBe(matterPort + (bridgeMode === 'bridge' ? 1 : 0));
-    expect(matterbridge.passcode).toBe(passcode + (bridgeMode === 'bridge' ? 1 : 0));
-    expect(matterbridge.discriminator).toBe(discriminator + (bridgeMode === 'bridge' ? 1 : 0));
-    if (bridgeMode === 'bridge') {
-        const started = new Promise((resolve) => {
-            matterbridge.once('bridge_started', () => {
-                resolve();
-            });
-        });
-        const online = new Promise((resolve) => {
-            matterbridge.once('online', (name) => {
-                if (name === 'Matterbridge')
-                    resolve();
-            });
-        });
-        await Promise.all([started, online]);
-    }
-    else if (bridgeMode === 'childbridge') {
-        await new Promise((resolve) => {
-            matterbridge.once('childbridge_started', () => {
-                resolve();
-            });
-        });
-    }
-    expect(loggerLogSpy).toHaveBeenCalledWith("info", `The frontend http server is listening on ${UNDERLINE}http://${matterbridge.systemInformation.ipv4Address}:${frontendPort}${UNDERLINEOFF}${rs}`);
-    if (bridgeMode === 'bridge') {
-        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Starting Matterbridge server node`);
-        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Server node for Matterbridge is online`);
-        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Starting start matter interval in bridge mode...`);
-        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Cleared startMatterInterval interval in bridge mode`);
-        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Matterbridge bridge started successfully`);
-    }
-    else if (bridgeMode === 'childbridge') {
-        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Starting start matter interval in childbridge mode...`);
-        expect(loggerLogSpy).toHaveBeenCalledWith("debug", `Cleared startMatterInterval interval in childbridge mode`);
-        expect(loggerLogSpy).toHaveBeenCalledWith("notice", `Matterbridge childbridge started successfully`);
-    }
-    return matterbridge;
-}
-export async function stopMatterbridge(cleanupPause = 10, destroyPause = 250, closeMdns = true) {
-    await destroyMatterbridgeEnvironment(cleanupPause, destroyPause, closeMdns);
-}
-export async function createMatterbridgeEnvironment(name, createOnly = false) {
-    log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: "debug" });
-    matterbridge = await Matterbridge.loadInstance(false);
-    expect(matterbridge).toBeDefined();
-    expect(matterbridge).toBeInstanceOf(Matterbridge);
-    matterbridge.matterbridgeVersion = '3.7.5';
-    matterbridge.bridgeMode = 'bridge';
-    matterbridge.rootDirectory = path.join(HOMEDIR);
-    matterbridge.homeDirectory = path.join(HOMEDIR);
-    matterbridge.matterbridgeDirectory = path.join(HOMEDIR, '.matterbridge');
-    matterbridge.matterbridgePluginDirectory = path.join(HOMEDIR, 'Matterbridge');
-    matterbridge.matterbridgeCertDirectory = path.join(HOMEDIR, '.mattercert');
-    matterbridge.log.logLevel = "debug";
-    frontend = matterbridge.frontend;
-    plugins = matterbridge.plugins;
-    devices = matterbridge.devices;
-    matterbridge.environment = createTestEnvironment(name, createOnly);
-    expect(matterbridge.environment).toBeDefined();
-    expect(matterbridge.environment).toBeInstanceOf(Environment);
-    return matterbridge;
-}
-export async function startMatterbridgeEnvironment(port = 5540, createOnly = false) {
-    matterbridge.nodeStorage = new NodeStorageManager({
-        dir: path.join(matterbridge.matterbridgeDirectory, NODE_STORAGE_DIR),
-        writeQueue: false,
-        expiredInterval: undefined,
-        logging: false,
-    });
-    matterbridge.nodeContext = await matterbridge.nodeStorage.createStorage('matterbridge');
-    await matterbridge.startMatterStorage();
-    expect(matterbridge.matterStorageService).toBeDefined();
-    expect(matterbridge.matterStorageManager).toBeDefined();
-    expect(matterbridge.matterbridgeContext).toBeDefined();
-    server = await matterbridge.createServerNode(matterbridge.matterbridgeContext, port);
-    expect(server).toBeDefined();
-    expect(server).toBeDefined();
-    expect(server.lifecycle.isReady).toBeTruthy();
-    matterbridge.serverNode = server;
-    aggregator = await matterbridge.createAggregatorNode(matterbridge.matterbridgeContext);
-    expect(aggregator).toBeDefined();
-    matterbridge.aggregatorNode = aggregator;
-    expect(await server.add(aggregator)).toBeDefined();
-    expect(server.parts.has(aggregator.id)).toBeTruthy();
-    expect(server.parts.has(aggregator)).toBeTruthy();
-    expect(aggregator.lifecycle.isReady).toBeTruthy();
-    if (createOnly) {
-        await flushAsync();
-        return [server, aggregator];
-    }
-    expect(server.lifecycle.isOnline).toBeFalsy();
-    await new Promise((resolve) => {
-        server.lifecycle.online.on(async () => {
-            resolve();
-        });
-        server.start();
-    });
-    expect(server.lifecycle.isReady).toBeTruthy();
-    expect(server.lifecycle.isOnline).toBeTruthy();
-    expect(server.lifecycle.isCommissioned).toBeFalsy();
-    expect(server.lifecycle.isPartsReady).toBeTruthy();
-    expect(server.lifecycle.hasId).toBeTruthy();
-    expect(server.lifecycle.hasNumber).toBeTruthy();
-    expect(aggregator.lifecycle.isReady).toBeTruthy();
-    expect(aggregator.lifecycle.isInstalled).toBeTruthy();
-    expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
-    expect(aggregator.lifecycle.hasId).toBeTruthy();
-    expect(aggregator.lifecycle.hasNumber).toBeTruthy();
-    await flushAsync();
-    return [server, aggregator];
-}
-export function addMatterbridgePlatform(platform, name) {
-    expect(platform).toBeDefined();
-    platform.setMatterNode?.(matterbridge.addBridgedEndpoint.bind(matterbridge), matterbridge.removeBridgedEndpoint.bind(matterbridge), matterbridge.removeAllBridgedEndpoints.bind(matterbridge), matterbridge.addVirtualEndpoint.bind(matterbridge));
-    if (name)
-        platform.config.name = name;
-    expect(platform.config.name).toBeDefined();
-    expect(platform.config.type).toBeDefined();
-    expect(platform.type).toBeDefined();
-    expect(platform.config.version).toBeDefined();
-    expect(platform.version).toBeDefined();
-    expect(platform.config.debug).toBeDefined();
-    expect(platform.config.unregisterOnShutdown).toBeDefined();
-    matterbridge.plugins._plugins.set(platform.config.name, {
-        name: platform.config.name,
-        path: './',
-        type: platform.type,
-        version: platform.version,
-        description: 'Plugin ' + platform.config.name,
-        author: 'Unknown',
-        enabled: true,
-    });
-    platform['name'] = platform.config.name;
-}
-export async function stopMatterbridgeEnvironment(createOnly = false) {
-    expect(matterbridge).toBeDefined();
-    expect(server).toBeDefined();
-    expect(aggregator).toBeDefined();
-    await flushAllEndpointNumberPersistence(server);
-    await assertAllEndpointNumbersPersisted(server);
-    expect(server.lifecycle.isReady).toBeTruthy();
-    if (!createOnly) {
-        expect(server.lifecycle.isOnline).toBeTruthy();
-    }
-    await server.close();
-    expect(server.lifecycle.isReady).toBeFalsy();
-    expect(server.lifecycle.isOnline).toBeFalsy();
-    await matterbridge.stopMatterStorage();
-    expect(matterbridge.matterStorageService).not.toBeDefined();
-    expect(matterbridge.matterStorageManager).not.toBeDefined();
-    expect(matterbridge.matterbridgeContext).not.toBeDefined();
-    await matterbridge.nodeContext?.close();
-    matterbridge.nodeContext = undefined;
-    await matterbridge.nodeStorage?.close();
-    matterbridge.nodeStorage = undefined;
-    await flushAsync();
-}
-export async function destroyMatterbridgeEnvironment(cleanupPause = 10, destroyPause = 250, closeMdns = true) {
-    await destroyInstance(matterbridge, cleanupPause, destroyPause);
-    if (closeMdns) {
-        await closeMdnsInstance(matterbridge);
-    }
-    Matterbridge.instance = undefined;
-}
-export async function destroyInstance(matterbridge, cleanupPause = 10, destroyPause = 250) {
-    await matterbridge.cleanup('destroying instance...', false, cleanupPause);
-    if (destroyPause > 0)
-        await flushAsync(undefined, undefined, destroyPause);
-}
-export async function closeMdnsInstance(matterbridge) {
-    const mdns = matterbridge.environment.get(MdnsService);
-    await mdns.close();
-}
-export function createTestEnvironment(name, createOnly = false) {
-    expect(name).toBeDefined();
-    expect(typeof name).toBe('string');
-    expect(name.length).toBeGreaterThanOrEqual(4);
-    log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: "debug" });
-    rmSync(path.join(HOMEDIR), { recursive: true, force: true });
-    environment = Environment.default;
-    environment.vars.set('log.level', MatterLogLevel.DEBUG);
-    environment.vars.set('log.format', MatterLogFormat.ANSI);
-    environment.vars.set('path.root', path.join(HOMEDIR, '.matterbridge', MATTER_STORAGE_DIR));
-    environment.vars.set('runtime.signals', false);
-    environment.vars.set('runtime.exitcode', false);
-    if (createOnly)
-        return environment;
-    new MdnsService(environment);
-    return environment;
-}
-export async function destroyTestEnvironment(createOnly = false) {
-    if (createOnly)
-        return;
-    const mdns = environment.get(MdnsService);
-    await mdns.close();
-}
-export async function flushAsync(ticks = 3, microTurns = 10, pause = 250) {
-    for (let i = 0; i < ticks; i++)
-        await new Promise((resolve) => setImmediate(resolve));
-    for (let i = 0; i < microTurns; i++)
-        await Promise.resolve();
-    if (pause)
-        await new Promise((resolve) => setTimeout(resolve, pause));
-}
-export function logKeepAlives(log) {
-    const handles = process._getActiveHandles?.() ?? [];
-    const requests = process._getActiveRequests?.() ?? [];
-    const fmtHandle = (h, i) => {
-        const ctor = h?.constructor?.name ?? 'Unknown';
-        const hasRef = typeof h?.hasRef === 'function' ? h.hasRef() : undefined;
-        const isPort = h?.constructor?.name?.includes('MessagePort');
-        const fd = h?.fd ?? h?._handle?.fd;
-        return { i, type: ctor, hasRef, isPort, fd };
-    };
-    const fmtReq = (r, i) => {
-        const ctor = r?.constructor?.name ?? 'Unknown';
-        return { i, type: ctor };
-    };
-    const summary = {
-        handles: handles.map(fmtHandle),
-        requests: requests.map(fmtReq),
-    };
-    if (summary.handles.length === 0 && summary.requests.length === 0) {
-        log?.debug('KeepAlive: no active handles or requests.');
-    }
-    else {
-        log?.debug(`KeepAlive:${rs}\n${inspect(summary, { depth: 5, colors: true })}`);
-        if (!log) {
-            process.stdout.write(`KeepAlive:\n${inspect(summary, { depth: 5, colors: true })}\n`);
-        }
-    }
-    return summary.handles.length + summary.requests.length;
-}
-export async function flushAllEndpointNumberPersistence(targetServer, rounds = 3, pause = 10) {
-    const nodeStore = targetServer.env.get(ServerNodeStore);
-    for (let i = 0; i < rounds; i++) {
-        await flushAsync(undefined, undefined, pause);
-        await nodeStore.endpointStores.close();
-    }
-}
-function getOwningServerNode(owner) {
-    let current = owner;
-    while (current.owner) {
-        current = current.owner;
-    }
-    return current;
-}
-function collectAllEndpoints(root) {
-    const list = [];
-    const walk = (ep) => {
-        list.push(ep);
-        if (ep.parts) {
-            for (const child of ep.parts) {
-                walk(child);
-            }
-        }
-    };
-    walk(root);
-    return list;
-}
-export async function assertAllEndpointNumbersPersisted(targetServer) {
-    const nodeStore = targetServer.env.get(ServerNodeStore);
-    await nodeStore.endpointStores.close();
-    const all = collectAllEndpoints(targetServer);
-    for (const ep of all) {
-        const store = nodeStore.storeForEndpoint(ep);
-        if (ep.maybeNumber === 0) {
-            expect(store.number ?? 0).toBe(0);
-        }
-        else {
-            expect(store.number).toBeGreaterThan(0);
-        }
-    }
-    return all.length;
-}
-export async function closeServerNodeStores(targetServer) {
-    if (!targetServer)
-        targetServer = server;
-    await targetServer?.env.get(ServerNodeStore)?.endpointStores.close();
-}
-export async function createServerNode(name, port, deviceType = bridge.code, ticks = 3, microTurns = 10, pause = 100) {
-    const { randomBytes } = await import('node:crypto');
-    const random = randomBytes(8).toString('hex');
-    server = await ServerNode.create({
-        id: name + 'ServerNode',
-        environment,
-        productDescription: {
-            name: name + 'ServerNode',
-            deviceType: DeviceTypeId(deviceType),
-            vendorId: VendorId(0xfff1),
-            productId: 0x8000,
-        },
-        basicInformation: {
-            vendorId: VendorId(0xfff1),
-            vendorName: 'Matterbridge',
-            productId: 0x8000,
-            productName: 'Matterbridge ' + name,
-            nodeLabel: name + 'ServerNode',
-            hardwareVersion: 1,
-            softwareVersion: 1,
-            reachable: true,
-            serialNumber: 'SN' + random,
-            uniqueId: 'UI' + random,
-        },
-        network: {
-            listeningAddressIpv4: undefined,
-            listeningAddressIpv6: undefined,
-            port,
-        },
-        operationalCredentials: {
-            certification: undefined,
-        },
-    });
-    expect(server).toBeDefined();
-    expect(server.lifecycle.isReady).toBeTruthy();
-    aggregator = new Endpoint(AggregatorEndpoint, {
-        id: name + 'AggregatorNode',
-    });
-    expect(aggregator).toBeDefined();
-    await server.add(aggregator);
-    expect(server.parts.has(aggregator.id)).toBeTruthy();
-    expect(server.parts.has(aggregator)).toBeTruthy();
-    expect(aggregator.lifecycle.isReady).toBeTruthy();
-    expect(server.lifecycle.isOnline).toBeFalsy();
-    await flushAsync(ticks, microTurns, pause);
-    return [server, aggregator];
-}
-export async function startServerNode(name, port, deviceType = bridge.code, createOnly = false, ticks = 3, microTurns = 10, pause = 100) {
-    if (!server || !aggregator) {
-        await createServerNode(name, port, deviceType);
-    }
-    if (createOnly) {
-        return [server, aggregator];
-    }
-    await new Promise((resolve) => {
-        server.lifecycle.online.on(async () => {
-            resolve();
-        });
-        server.start();
-    });
-    expect(server.lifecycle.isReady).toBeTruthy();
-    expect(server.lifecycle.isOnline).toBeTruthy();
-    expect(server.lifecycle.isCommissioned).toBeFalsy();
-    expect(server.lifecycle.isPartsReady).toBeTruthy();
-    expect(server.lifecycle.hasId).toBeTruthy();
-    expect(server.lifecycle.hasNumber).toBeTruthy();
-    expect(aggregator.lifecycle.isReady).toBeTruthy();
-    expect(aggregator.lifecycle.isInstalled).toBeTruthy();
-    expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
-    expect(aggregator.lifecycle.hasId).toBeTruthy();
-    expect(aggregator.lifecycle.hasNumber).toBeTruthy();
-    await flushAsync(ticks, microTurns, pause);
-    return [server, aggregator];
-}
-export async function stopServerNode(server, createOnly = false, ticks = 3, microTurns = 10, pause = 100) {
-    await flushAllEndpointNumberPersistence(server);
-    await assertAllEndpointNumbersPersisted(server);
-    expect(server).toBeDefined();
-    expect(server.lifecycle.isReady).toBeTruthy();
-    if (!createOnly) {
-        expect(server.lifecycle.isOnline).toBeTruthy();
-    }
-    await server.close();
-    expect(server.lifecycle.isReady).toBeFalsy();
-    expect(server.lifecycle.isOnline).toBeFalsy();
-    await flushAsync(ticks, microTurns, pause);
-}
-export async function addDevice(owner, device, pause = 10) {
-    expect(owner).toBeDefined();
-    expect(device).toBeDefined();
-    expect(owner.lifecycle.isReady).toBeTruthy();
-    expect(owner.construction.status).toBe(Lifecycle.Status.Active);
-    expect(owner.lifecycle.isPartsReady).toBeTruthy();
-    const targetServer = getOwningServerNode(owner);
-    await flushAllEndpointNumberPersistence(targetServer, 3, pause);
-    try {
-        await owner.add(device);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : error;
-        const errorInspect = inspect(error, { depth: 10 });
-        process.stderr.write(`${er}Error adding device ${device.maybeId}.${device.maybeNumber}: ${errorMessage}${rs}\nStack: ${errorInspect}\n`);
-        return false;
-    }
-    await device.construction.ready;
-    expect(owner.parts.has(device)).toBeTruthy();
-    expect(owner.lifecycle.isPartsReady).toBeTruthy();
-    expect(device.lifecycle.isReady).toBeTruthy();
-    expect(device.lifecycle.isInstalled).toBeTruthy();
-    expect(device.lifecycle.hasId).toBeTruthy();
-    expect(device.lifecycle.hasNumber).toBeTruthy();
-    expect(device.construction.status).toBe(Lifecycle.Status.Active);
-    await flushAllEndpointNumberPersistence(targetServer, 3, pause);
-    return true;
-}
-export async function deleteDevice(owner, device, pause = 10) {
-    expect(owner).toBeDefined();
-    expect(device).toBeDefined();
-    expect(owner.lifecycle.isReady).toBeTruthy();
-    expect(owner.construction.status).toBe(Lifecycle.Status.Active);
-    expect(owner.lifecycle.isPartsReady).toBeTruthy();
-    const targetServer = getOwningServerNode(owner);
-    await flushAllEndpointNumberPersistence(targetServer, 3, pause);
-    try {
-        await device.delete();
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : error;
-        const errorInspect = inspect(error, { depth: 10 });
-        process.stderr.write(`${er}Error deleting device ${device.maybeId}.${device.maybeNumber}: ${errorMessage}${rs}\nStack: ${errorInspect}\n`);
-        return false;
-    }
-    expect(owner.parts.has(device)).toBeFalsy();
-    expect(owner.lifecycle.isPartsReady).toBeTruthy();
-    expect(device.lifecycle.isReady).toBeFalsy();
-    expect(device.lifecycle.isInstalled).toBeFalsy();
-    expect(device.lifecycle.hasId).toBeTruthy();
-    expect(device.lifecycle.hasNumber).toBeTruthy();
-    expect(device.construction.status).toBe(Lifecycle.Status.Destroyed);
-    await flushAllEndpointNumberPersistence(targetServer, 3, pause);
-    return true;
-}
-export function getMoveToLevelRequest(level, transitionTime, executeIfOff) {
-    const request = {
-        level,
-        transitionTime,
-        optionsMask: { executeIfOff, coupleColorTempToLevel: false },
-        optionsOverride: { executeIfOff, coupleColorTempToLevel: false },
-    };
-    return request;
-}
-export function getMoveToColorTemperatureRequest(colorTemperatureMireds, transitionTime, executeIfOff) {
-    const request = {
-        colorTemperatureMireds,
-        transitionTime,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}
-export function getMoveToHueRequest(hue, transitionTime, executeIfOff) {
-    const request = {
-        hue,
-        transitionTime,
-        direction: ColorControl.Direction.Shortest,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}
-export function getEnhancedMoveToHueRequest(enhancedHue, transitionTime, executeIfOff) {
-    const request = {
-        enhancedHue,
-        transitionTime,
-        direction: ColorControl.Direction.Shortest,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}
-export function getMoveToSaturationRequest(saturation, transitionTime, executeIfOff) {
-    const request = {
-        saturation,
-        transitionTime,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}
-export function getMoveToHueAndSaturationRequest(hue, saturation, transitionTime, executeIfOff) {
-    const request = {
-        hue,
-        saturation,
-        transitionTime,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}
-export function getEnhancedMoveToHueAndSaturationRequest(enhancedHue, saturation, transitionTime, executeIfOff) {
-    const request = {
-        enhancedHue,
-        saturation,
-        transitionTime,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}
-export function getMoveToColorRequest(colorX, colorY, transitionTime, executeIfOff) {
-    const request = {
-        colorX,
-        colorY,
-        transitionTime,
-        optionsMask: { executeIfOff },
-        optionsOverride: { executeIfOff },
-    };
-    return request;
-}