matterbridge-roborock-vacuum-plugin/dist/tests/platformRunner3.test.js

Matterbridge Roborock Vacuum Plugin

import { RvcOperationalState, RvcRunMode } from 'matterbridge/matter/clusters';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { CleanModeSetting } from '../behaviors/roborock.vacuum/core/CleanModeSetting.js';
import { CleanSequenceType } from '../behaviors/roborock.vacuum/enums/CleanSequenceType.js';
import { PlatformRunner } from '../platformRunner.js';
import { OperationStatusCode } from '../roborockCommunication/enums/index.js';
import { DeviceModel } from '../roborockCommunication/models/index.js';
import { NotifyMessageTypes } from '../types/notifyMessageTypes.js';
import { asPartial, createMockConfigManager, createMockDeviceRegistry, createMockLogger, createMockRoborockService, } from './testUtils.js';
vi.mock('../runtimes/handleHomeDataMessage.js', () => ({
    updateFromHomeData: vi.fn(),
}));
vi.mock('../runtimes/handleLocalMessage.js', () => ({
    triggerDssError: vi.fn().mockResolvedValue(false),
}));
vi.mock('../model/DockStationStatus.js', async (importOriginal) => {
    const actual = await importOriginal();
    return {
        ...actual,
        hasDockingStationError: vi.fn().mockReturnValue(false),
    };
});
describe('PlatformRunner.updateRobotWithPayload - resolved state logging', () => {
    let platform;
    let runner;
    let robot;
    const mockLogger = createMockLogger();
    beforeEach(() => {
        const mapInfo = asPartial({
            getActiveMapId: vi.fn().mockReturnValue(1),
        });
        robot = asPartial({
            serialNumber: 'test-duid',
            device: asPartial({
                duid: 'test-duid',
                name: 'test-device',
                specs: asPartial({ model: DeviceModel.S7 }),
            }),
            updateAttribute: vi.fn().mockResolvedValue(true),
            getAttribute: vi.fn().mockImplementation((clusterId, attribute) => {
                if (clusterId === RvcRunMode.Cluster.id && attribute === 'currentMode')
                    return 1;
                if (clusterId === RvcOperationalState.Cluster.id && attribute === 'operationalState')
                    return RvcOperationalState.OperationalState.Paused;
            }),
            setAttribute: vi.fn(),
            cleanModeSetting: new CleanModeSetting(1, 1, 1, 1, CleanSequenceType.Persist),
            dockStationStatus: asPartial({}),
            homeInFo: asPartial({ activeMapId: 0, mapInfo }),
        });
        platform = asPartial({
            registry: createMockDeviceRegistry({}, new Map([['test-duid', robot]])),
            log: mockLogger,
            roborockService: createMockRoborockService(),
            configManager: createMockConfigManager({ includeVacuumErrorStatus: true }),
        });
        runner = new PlatformRunner(platform);
        runner.activateHandlerFunctions();
        vi.clearAllMocks();
    });
    it('should log resolved state for Paused status (status=10) with inCleaning=true', async () => {
        const statusMessage = {
            duid: 'test-duid',
            status: OperationStatusCode.Paused,
            inCleaning: true,
            inReturning: false,
            inFreshState: false,
            isLocating: false,
            isExploring: false,
            inWarmup: undefined,
        };
        const payload = { type: NotifyMessageTypes.DeviceStatus, data: statusMessage };
        await runner.updateRobotWithPayload(payload);
        expect(mockLogger.notice).toHaveBeenCalledOnce();
        const logOutput = vi.mocked(mockLogger.notice).mock.calls[0][0];
        // console.log('log.notice output:\n', logOutput);
        expect(logOutput).toContain('[test-duid] [test-device] Resolved state:');
        expect(robot.updateAttribute).toHaveBeenCalledWith(RvcRunMode.Cluster.id, 'currentMode', 2, mockLogger);
        expect(robot.updateAttribute).toHaveBeenCalledWith(RvcOperationalState.Cluster.id, 'operationalState', RvcOperationalState.OperationalState.Paused, mockLogger);
    });
});
//# sourceMappingURL=platformRunner3.test.js.map