matterbridge-roborock-vacuum-plugin
Version:
Matterbridge Roborock Vacuum Plugin
156 lines • 8.21 kB
JavaScript
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { RoomIndexMap } from '../../../core/application/models/index.js';
import { PlatformConfigManager as PlatformConfigManagerStatic } from '../../../platform/platformConfigManager.js';
import { RoborockService } from '../../../services/roborockService.js';
import { createMockAuthApi, createMockIotApi, createMockLocalStorage, createMockLogger } from '../../testUtils.js';
describe('RoborockService - Area Management', () => {
let roborockService;
let mockLogger;
beforeEach(() => {
mockLogger = createMockLogger();
const PlatformConfigManager = PlatformConfigManagerStatic;
const config = {
authentication: {
username: 'test',
region: 'US',
forceAuthentication: false,
authenticationMethod: 'Password',
password: '',
},
pluginConfiguration: {
whiteList: [],
enableServerMode: false,
enableMultipleMap: false,
sanitizeSensitiveLogs: false,
refreshInterval: 10,
debug: false,
unregisterOnShutdown: false,
},
advancedFeature: {
enableAdvancedFeature: false,
settings: {
clearStorageOnStartup: false,
enableLiveMapUpdates: false,
showRoutinesAsRoom: false,
includeDockStationStatus: false,
includeVacuumErrorStatus: false,
forceRunAtDefault: false,
useVacationModeToSendVacuumToDock: false,
enableCleanModeMapping: false,
cleanModeSettings: {
vacuuming: { fanMode: 'Balanced', mopRouteMode: 'Standard' },
mopping: { waterFlowMode: 'Medium', mopRouteMode: 'Standard', distanceOff: 25 },
vacmop: { fanMode: 'Balanced', waterFlowMode: 'Medium', mopRouteMode: 'Standard', distanceOff: 25 },
},
overrideMatterConfiguration: false,
matterOverrideSettings: {
matterVendorName: 'xxx',
matterVendorId: 123,
matterProductName: 'yy',
matterProductId: 456,
},
enableEmailNotification: false,
emailNotificationSettings: {},
},
},
};
const configManager = PlatformConfigManager.create(config, mockLogger);
roborockService = new RoborockService({
authenticateApiFactory: () => createMockAuthApi(),
iotApiFactory: () => createMockIotApi(),
refreshInterval: 10,
baseUrl: 'https://api.roborock.com',
persist: createMockLocalStorage(),
configManager: configManager,
toastMessage: vi.fn(),
}, mockLogger, configManager);
const roomInfo = new Map([]);
roborockService.setSupportedAreaIndexMap('duid-123', new RoomIndexMap(new Map([
[1, { roomId: 1, mapId: 1, roomName: 'rn-1' }],
[2, { roomId: 2, mapId: 2, roomName: 'rn-2' }],
]), roomInfo));
});
it('should set selected areas', () => {
roborockService.setSelectedAreas('duid-123', [1, 2]);
expect(roborockService.getSelectedAreas('duid-123')).toEqual([1, 2]);
});
it('should clear selected areas', () => {
roborockService.setSelectedAreas('duid-123', []);
expect(roborockService.getSelectedAreas('duid-123')).toEqual([]);
});
it('should filter out invalid areas', () => {
roborockService.setSelectedAreas('duid-123', [7, 8]);
expect(roborockService.getSelectedAreas('duid-123')).toEqual([7, 8]);
});
describe('new delegation methods', () => {
const duid = 'duid-delegate';
it('registerAreasListener delegates to areaService.registerAreasListener', () => {
const cb = vi.fn();
roborockService.registerAreasListener(duid, cb);
// Verify by triggering a setSupportedAreas that invokes the callback
roborockService.setSupportedAreas(duid, []);
expect(cb).toHaveBeenCalledWith([], []);
});
it('setSupportedMaps delegates to areaService.setSupportedMaps', () => {
const maps = [{ mapId: 1, name: 'Map 1' }];
roborockService.setSupportedMaps(duid, maps);
expect(roborockService.getSupportedMaps(duid)).toEqual(maps);
});
it('getSupportedMaps delegates to areaService.getSupportedMaps', () => {
expect(roborockService.getSupportedMaps('unknown-duid')).toEqual([]);
});
it('startPeriodicAreaRefresh delegates to areaService.startPeriodicRefresh', () => {
// Just verifies it does not throw
expect(() => roborockService.startPeriodicAreaRefresh(duid, 99999999)).not.toThrow();
});
it('getSupportedRoutines delegates to areaService.getSupportedRoutines', () => {
expect(roborockService.getSupportedRoutines('unknown-duid')).toBeUndefined();
});
it('setDeviceRooms delegates to areaService.setDeviceRooms', () => {
expect(() => roborockService.setDeviceRooms(duid, [])).not.toThrow();
});
it('switchMap delegates to messageRoutingService.switchMap', async () => {
// switchMap requires a registered dispatcher; should throw DeviceError when none
await expect(roborockService.switchMap(duid, 1)).rejects.toThrow();
});
it('setProgress delegates to areaService.setProgress', () => {
const progress = [{ areaId: 1, status: 0 }];
roborockService.setProgress(duid, progress);
expect(roborockService.getProgress(duid)).toEqual(progress);
});
it('getProgress delegates to areaService.getProgress', () => {
expect(roborockService.getProgress('unknown-duid')).toEqual([]);
});
it('getProgress returns progress array previously set via setProgress', () => {
const duid2 = 'duid-progress-test';
const progress = [{ areaId: 5, status: 1 }];
roborockService.setProgress(duid2, progress);
expect(roborockService.getProgress(duid2)).toEqual(progress);
});
it('setLastActivelyCleaningState delegates to areaService.setLastActivelyCleaningState', () => {
roborockService.setLastActivelyCleaningState(duid, true);
expect(roborockService.getLastActivelyCleaningState(duid)).toBe(true);
});
it('getLastActivelyCleaningState delegates to areaService.getLastActivelyCleaningState', () => {
expect(roborockService.getLastActivelyCleaningState('unknown-duid')).toBe(false);
});
it('getLastActivelyCleaningState returns state previously set via setLastActivelyCleaningState', () => {
const duid2 = 'duid-state-test';
roborockService.setLastActivelyCleaningState(duid2, true);
expect(roborockService.getLastActivelyCleaningState(duid2)).toBe(true);
});
it('getLastActivelyCleaningState defaults to false for unset duid', () => {
expect(roborockService.getLastActivelyCleaningState('new-duid-123')).toBe(false);
});
it('setLastActivelyCleaningState can toggle state between true and false', () => {
const duid2 = 'duid-toggle-test';
roborockService.setLastActivelyCleaningState(duid2, true);
expect(roborockService.getLastActivelyCleaningState(duid2)).toBe(true);
roborockService.setLastActivelyCleaningState(duid2, false);
expect(roborockService.getLastActivelyCleaningState(duid2)).toBe(false);
roborockService.setLastActivelyCleaningState(duid2, true);
expect(roborockService.getLastActivelyCleaningState(duid2)).toBe(true);
});
});
});
//# sourceMappingURL=roborockService.areamanagement.test.js.map