matterbridge-roborock-vacuum-plugin/dist/tests/behaviors/roborock.vacuum/core/modeHandlerRegistry.test.js

Matterbridge Roborock Vacuum Plugin

import { describe, expect, it, vi } from 'vitest';
import { CleanModeSetting } from '../../../../behaviors/roborock.vacuum/core/CleanModeSetting.js';
import { ModeHandlerRegistry } from '../../../../behaviors/roborock.vacuum/core/modeHandlerRegistry.js';
import { CleanSequenceType } from '../../../../behaviors/roborock.vacuum/enums/CleanSequenceType.js';
import { createDefaultCleanModeSettings } from '../../../../model/RoborockPluginPlatformConfig.js';
import { asPartial, createMockLogger } from '../../../helpers/testUtils.js';
describe('ModeHandlerRegistry', () => {
    it('registers handlers and returns this for chaining', () => {
        const registry = new ModeHandlerRegistry();
        const handler = {
            canHandle: () => false,
            handle: async () => { },
        };
        const result = registry.register(handler);
        expect(result).toBe(registry);
    });
    it('routes to correct handler when canHandle returns true', async () => {
        const registry = new ModeHandlerRegistry();
        const mockHandle = vi.fn().mockResolvedValue(undefined);
        const handler1 = {
            canHandle: () => false,
            handle: async () => { },
        };
        const handler2 = {
            canHandle: (mode, activity) => activity === 'Cleaning',
            handle: mockHandle,
        };
        registry.register(handler1).register(handler2);
        const context = {
            roborockService: {},
            logger: createMockLogger(),
            cleanSettings: {},
            behaviorName: 'TestBehavior',
            enableCleanModeMapping: false,
        };
        await registry.handle('test-duid', 2, 'Cleaning', context);
        expect(mockHandle).toHaveBeenCalledWith('test-duid', 2, 'Cleaning', context);
        expect(mockHandle).toHaveBeenCalledTimes(1);
    });
    it('routes to first matching handler when multiple handlers can handle', async () => {
        const registry = new ModeHandlerRegistry();
        const mockHandle1 = vi.fn().mockResolvedValue(undefined);
        const mockHandle2 = vi.fn().mockResolvedValue(undefined);
        const handler1 = {
            canHandle: () => true,
            handle: mockHandle1,
        };
        const handler2 = {
            canHandle: () => true,
            handle: mockHandle2,
        };
        registry.register(handler1).register(handler2);
        const context = {
            roborockService: {},
            logger: createMockLogger(),
            cleanSettings: {},
            behaviorName: 'TestBehavior',
            enableCleanModeMapping: false,
        };
        await registry.handle('test-duid', 1, 'Test', context);
        expect(mockHandle1).toHaveBeenCalledTimes(1);
        expect(mockHandle2).not.toHaveBeenCalled();
    });
    it('logs unknown mode when no handler can handle', async () => {
        const registry = new ModeHandlerRegistry();
        const mockNotice = vi.fn();
        const handler = {
            canHandle: () => false,
            handle: async () => { },
        };
        registry.register(handler);
        const context = {
            roborockService: {},
            logger: Object.assign(createMockLogger(), { notice: mockNotice }),
            cleanSettings: {},
            behaviorName: 'TestBehavior',
            enableCleanModeMapping: false,
        };
        await registry.handle('test-duid', 99, 'Unknown', context);
        expect(mockNotice).toHaveBeenCalledWith('TestBehavior-changeToMode-Unknown: ', 99);
    });
    it('passes all parameters correctly to handler', async () => {
        const registry = new ModeHandlerRegistry();
        const mockHandle = vi.fn().mockResolvedValue(undefined);
        const handler = {
            canHandle: () => true,
            handle: mockHandle,
        };
        registry.register(handler);
        const context = {
            roborockService: asPartial({}),
            logger: { notice: vi.fn() },
            cleanModeSettings: createDefaultCleanModeSettings(),
            cleanSettings: { 5: new CleanModeSetting(102, 202, 0, 300, CleanSequenceType.Persist) },
            behaviorName: 'SmartBehavior',
            enableCleanModeMapping: true,
        };
        await registry.handle('duid-123', 5, 'Vacuum & Mop: Default', context);
        expect(mockHandle).toHaveBeenCalledWith('duid-123', 5, 'Vacuum & Mop: Default', context);
    });
    it('handles empty registry gracefully', async () => {
        const registry = new ModeHandlerRegistry();
        const mockNotice = vi.fn();
        const context = {
            roborockService: {},
            logger: Object.assign(createMockLogger(), { notice: mockNotice }),
            cleanSettings: {},
            enableCleanModeMapping: false,
            behaviorName: 'TestBehavior',
        };
        await registry.handle('test-duid', 1, 'Test', context);
        expect(mockNotice).toHaveBeenCalledWith('TestBehavior-changeToMode-Unknown: ', 1);
    });
});
//# sourceMappingURL=modeHandlerRegistry.test.js.map