Codex
453 lines
17 KiB
JavaScript
453 lines
17 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import {
|
|
JilianControlBoxAdapter,
|
|
JilianSmartSocketAdapter,
|
|
JilianSub1GLockAdapter
|
|
} from '../dist/devices/jilian-adapters.js';
|
|
import {
|
|
generateCommandId,
|
|
IotMessageService
|
|
} from '../dist/devices/iot-message-service.js';
|
|
import { DeviceCommandService } from '../dist/devices/device-command-service.js';
|
|
|
|
const control = new JilianControlBoxAdapter();
|
|
assert.deepEqual(control.read('basicInfo'), { read: 'basicInfo' });
|
|
assert.deepEqual(control.controlPower({
|
|
id: '1234567890123', slot1: 'on', slot3: 'off'
|
|
}), {
|
|
action: 'ConctolPower', id: '1234567890123', slot1: 'on', slot3: 'off'
|
|
});
|
|
assert.equal(control.controlDoor({
|
|
id: '1234567890123', order: 'open'
|
|
}).action, 'Crldoor');
|
|
assert.deepEqual(control.playTts({
|
|
id: '1234567890123', content: '欢迎光临', volume: 7, firstPlay: 1,
|
|
loop: 2, speaker: 3, style: 2, speed: 6, intonation: 4
|
|
}), {
|
|
action: 'PlayTTS', content: '欢迎光临', vol: 7, firstPlay: 1,
|
|
loop: 2, speaker: 3, style: 2, speed: 6, intona: 4,
|
|
id: '1234567890123'
|
|
});
|
|
assert.deepEqual(control.stopTts('1234567890123'), {
|
|
action: 'stopTTS', id: '1234567890123'
|
|
});
|
|
assert.equal(control.controlLed({ id: '1234567890123', minute: 30 }).action, 'CrlLED');
|
|
assert.equal(control.startTask({
|
|
id: '1234567890123', minute: 120, type: 2, subID: 'SUB001'
|
|
}).action, 'task');
|
|
assert.equal(control.extendTask({
|
|
id: '1234567890123', addminute: 30
|
|
}).action, 'addtask');
|
|
assert.equal(control.cancelTask('1234567890123').action, 'canceltask');
|
|
assert.throws(
|
|
() => control.controlDoor({ id: '12345678901234', order: 'open' }),
|
|
/Invalid/
|
|
);
|
|
assert.throws(
|
|
() => control.controlDoor({ id: '123', order: 'open', delayTime: 15 }),
|
|
/less than or equal to 14/
|
|
);
|
|
|
|
const lock = new JilianSub1GLockAdapter();
|
|
assert.deepEqual(lock.pair({ id: '123', timeout: 60 }), {
|
|
action: 'AddDevice', time: 60, id: '123'
|
|
});
|
|
assert.deepEqual(lock.control({
|
|
id: '123', subtype: '14', subID: 'SUB001', order: 'setcard',
|
|
value: 'a1b2c3d4'
|
|
}), {
|
|
action: 'CtrlDevice', subtype: '14', subID: 'SUB001', order: 'setcard',
|
|
value: 'A1B2C3D4', id: '123'
|
|
});
|
|
assert.throws(
|
|
() => lock.control({
|
|
id: '123', subtype: '14', subID: 'SUB001', order: 'setkey', value: '12345'
|
|
}),
|
|
/6-digit passwords/
|
|
);
|
|
assert.throws(
|
|
() => lock.control({
|
|
id: '123', subtype: '15', subID: 'SUB001', order: 'setcard', value: 'not-card'
|
|
}),
|
|
/8-digit hex card IDs/
|
|
);
|
|
|
|
const socket = new JilianSmartSocketAdapter();
|
|
assert.deepEqual(socket.read('workInfo'), { read: 'workInfo', slotNum: 1 });
|
|
assert.deepEqual(socket.read({ target: 'localtask', slotNum: 2, taskNum: 7 }), {
|
|
read: 'localtask', slotNum: 2, taskNum: 7
|
|
});
|
|
assert.deepEqual(socket.read({ target: 'localtask', taskNum: 0 }), {
|
|
read: 'localtask', slotNum: 1, taskNum: 0
|
|
});
|
|
assert.deepEqual(socket.read({ target: 'mqttConfig' }), { read: 'mqttConfig' });
|
|
assert.deepEqual(socket.switch({ id: '123', on: true }), {
|
|
action: 'on', id: '123', slotNum: 1
|
|
});
|
|
assert.deepEqual(socket.localTask({
|
|
id: '123', taskNum: 20, action: 'off', mode: 'weekly',
|
|
time: '23:00', weekdays: [1, 5]
|
|
}), {
|
|
action: 'localtask', slotNum: 1, taskNum: 20, tasktype: 'off',
|
|
cyctype: 'weekcyc', weekdata: '1000100', actiontime: '2300', id: '123'
|
|
});
|
|
assert.throws(() => socket.localTask({
|
|
id: '123', taskNum: 0, action: 'on', mode: 'once', time: '12:00'
|
|
}), /greater than or equal to 1/);
|
|
assert.throws(() => socket.localTask({
|
|
id: '123', taskNum: 1, action: 'on', mode: 'weekly', time: '24:00',
|
|
weekdays: [1]
|
|
}), /Invalid/);
|
|
assert.throws(() => socket.localTask({
|
|
id: '123', taskNum: 1, action: 'on', mode: 'weekly', time: '12:00',
|
|
weekdays: [1, 1]
|
|
}), /weekdays must be unique/);
|
|
assert.deepEqual(socket.clearTask({ id: '123', taskNum: 0 }), {
|
|
action: 'clearTask', id: '123', slotNum: 1, taskNum: 0
|
|
});
|
|
assert.deepEqual(socket.parameter({
|
|
id: '123', resetHold: 1, keyLock: 0, keyOff: 1
|
|
}), { setting: 'parameter', resetHold: 1, keyLock: 0, KeyOff: 1, id: '123' });
|
|
assert.equal(socket.reboot('123').action, 'reboot');
|
|
assert.equal(socket.emptyPower('123').action, 'emptyPower');
|
|
assert.deepEqual(socket.returnFactory({ id: '123', password: 'secret' }), {
|
|
action: 'returnFactory', password: 'secret', id: '123'
|
|
});
|
|
assert.deepEqual(socket.setReturnKey({ id: '123', old: 'old-key', new: 'new-key' }), {
|
|
action: 'setReturnKey', old: 'old-key', new: 'new-key', id: '123'
|
|
});
|
|
const protection = socket.protectOff({
|
|
id: '123', ratedAmps: 16, maxPower: 3500, maxCurrent: 15,
|
|
maxTemperature: 80, pullOutStop: 1, pullOutPower: 5, pullOutSec: 10,
|
|
chargeFullStop: 1, chargeFullPower: 8, chargeFullSec: 30
|
|
});
|
|
assert.equal(protection.setting, 'protectOff');
|
|
assert.equal('ratedAmps' in protection, false);
|
|
for (const ratedAmps of [10, 63]) {
|
|
const ratedProtection = socket.protectOff({
|
|
id: '123', ratedAmps, maxPower: ratedAmps * 250, maxCurrent: ratedAmps,
|
|
maxTemperature: 100, pullOutStop: 0, pullOutPower: 0, pullOutSec: 1,
|
|
chargeFullStop: 0, chargeFullPower: 0, chargeFullSec: 1
|
|
});
|
|
assert.equal(ratedProtection.maxCurrent, ratedAmps);
|
|
}
|
|
assert.throws(() => socket.protectOff({
|
|
id: '123', ratedAmps: 10, maxPower: 2600, maxCurrent: 11,
|
|
maxTemperature: 80, pullOutStop: 1, pullOutPower: 5, pullOutSec: 10,
|
|
chargeFullStop: 1, chargeFullPower: 8, chargeFullSec: 30
|
|
}), /10A capability/);
|
|
|
|
const ack = control.parseUplink({
|
|
DeviceID: 'BOX_001', id: '123', result: 'unconfirm', action: 'task'
|
|
});
|
|
assert.equal(ack.kind, 'ACK');
|
|
assert.equal(ack.result, 'unconfirm');
|
|
assert.equal(ack.eventType, 'task');
|
|
assert.equal(control.parseUplink({
|
|
DeviceID: 'BOX_001', id: '124', result: 'paraerror', action: 'PlayTTS'
|
|
}).result, 'paraerror');
|
|
assert.equal(control.parseUplink({
|
|
DeviceID: 'BOX_001', id: '125', result: 'vendor-new-code', action: 'task'
|
|
}).result, 'UNKNOWN_VENDOR_RESULT');
|
|
const configVariant = control.parseUplink({
|
|
DeviceID: 'BOX_001', setting: 'mqttconfig', welvoice: 'hello'
|
|
});
|
|
assert.equal(configVariant.eventType, 'mqttConfig');
|
|
assert.equal(configVariant.payload.welcomevoice, 'hello');
|
|
const event = lock.parseUplink({
|
|
deviceID: 'BOX_001', event: 'record', type: 'card', state: 'open',
|
|
timestamp: 1782120000
|
|
});
|
|
assert.equal(event.kind, 'EVENT');
|
|
assert.equal(event.eventType, 'record');
|
|
assert.equal(event.eventAt?.getUTCFullYear(), 2026);
|
|
for (const eventType of ['magstate', 'taskfinish', 'Poweron', 'connected']) {
|
|
const fixture = control.parseUplink({
|
|
DeviceID: 'BOX_001', event: eventType, state: 'open', timestamp: 1782120000
|
|
});
|
|
assert.equal(fixture.kind, 'EVENT');
|
|
assert.equal(fixture.eventType, eventType);
|
|
}
|
|
const workInfo = socket.parseUplink({
|
|
DeviceID: 'SOCKET_001', read: 'workInfo', onOff: 'on',
|
|
vol: '0220.5000', cur: '01.250', pow: '00275.000', temp: '45.50', energy: '0012.3400'
|
|
});
|
|
assert.deepEqual({
|
|
switchOn: workInfo.payload.switchOn,
|
|
voltage: workInfo.payload.voltage,
|
|
current: workInfo.payload.current,
|
|
power: workInfo.payload.power,
|
|
temperature: workInfo.payload.temperature,
|
|
energy: workInfo.payload.energy
|
|
}, {
|
|
switchOn: true, voltage: '220.5', current: '1.25', power: '275',
|
|
temperature: '45.5', energy: '12.34'
|
|
});
|
|
const temperatureVariant = socket.parseUplink({
|
|
DeviceID: 'SOCKET_001', read: 'workInfo', temperature: '46.0', KeyOff: 1
|
|
});
|
|
assert.equal(temperatureVariant.payload.temperature, '46');
|
|
assert.equal(temperatureVariant.payload.keyOff, 1);
|
|
const conflictingTemperature = socket.parseUplink({
|
|
DeviceID: 'SOCKET_001', read: 'workInfo', temp: '45', temperature: '46'
|
|
});
|
|
assert.deepEqual(conflictingTemperature.protocolIssues, ['SOCKET_TEMPERATURE_CONFLICT']);
|
|
for (const [action, result] of [
|
|
['off', 'update'], ['off', 'paraerror'], ['localtask', 'error']
|
|
]) {
|
|
const response = socket.parseUplink({
|
|
DeviceID: 'SOCKET_001', id: `20${result.length}`, action, result
|
|
});
|
|
assert.equal(response.kind, 'ACK');
|
|
assert.equal(response.result, result);
|
|
}
|
|
|
|
assert.equal(generateCommandId(1782120000000, 7), '1782120000007');
|
|
assert.match(generateCommandId(), /^\d{13}$/);
|
|
|
|
const calls = [];
|
|
const eventHashes = new Set();
|
|
const service = new IotMessageService({
|
|
async execute(sql, params) {
|
|
calls.push({ sql, params });
|
|
if (sql.includes('FROM qipai_devices')) {
|
|
if (params[0] === 'SOCKET_001') {
|
|
return [[{
|
|
id: 52, tenantId: 7, storeId: 11, roomId: 31,
|
|
deviceId: 'SOCKET_001', deviceType: 'SMART_SOCKET'
|
|
}], []];
|
|
}
|
|
return [[{
|
|
id: 51, tenantId: 7, storeId: 11, roomId: 31,
|
|
deviceId: 'BOX_001', deviceType: 'CONTROL_BOX'
|
|
}], []];
|
|
}
|
|
if (sql.includes('INSERT INTO qipai_iot_device_events')) {
|
|
const hash = params[7];
|
|
const duplicate = eventHashes.has(hash);
|
|
eventHashes.add(hash);
|
|
return [{ affectedRows: duplicate ? 2 : 1 }, []];
|
|
}
|
|
return [{ affectedRows: 1, insertId: 81 }, []];
|
|
}
|
|
});
|
|
const payload = Buffer.from(JSON.stringify({
|
|
DeviceID: 'BOX_001', id: '123', result: 'ok', action: 'ConctolPower',
|
|
slot1: 'on'
|
|
}));
|
|
await service.handle('/devicesend/BOX_001', payload);
|
|
await service.handle('/devicesend/BOX_001', payload);
|
|
assert.equal(
|
|
calls.filter((item) => item.sql.includes('UPDATE qipai_iot_commands')).length,
|
|
1,
|
|
'duplicate QoS 1 payload must not repeat command/device side effects'
|
|
);
|
|
assert.equal(
|
|
calls.some((item) => item.sql.includes('qipai_iot_dead_letters')),
|
|
false
|
|
);
|
|
|
|
await service.handle('/bad-topic/BOX_001', Buffer.from('{}'));
|
|
assert.equal(
|
|
calls.some((item) => item.sql.includes('qipai_iot_dead_letters')),
|
|
true
|
|
);
|
|
|
|
const recordPayload = Buffer.from(JSON.stringify({
|
|
DeviceID: 'BOX_001', event: 'record', type: 'card',
|
|
state: 'open', content: 'CARD-PRIVATE-1234', battery: 9
|
|
}));
|
|
await service.handle('/devicesend/BOX_001', recordPayload);
|
|
const recordInsert = calls.findLast((item) =>
|
|
item.sql.includes('INSERT INTO qipai_iot_device_events')
|
|
);
|
|
assert.equal(recordInsert.params.some((value) =>
|
|
typeof value === 'string' && value.includes('CARD-PRIVATE-1234')
|
|
), false);
|
|
assert.equal(calls.some((item) =>
|
|
item.sql.includes('INSERT INTO qipai_device_alerts')
|
|
&& item.params.includes('LOW_BATTERY')
|
|
), true);
|
|
|
|
await service.handle('/devicesend/BOX_001', Buffer.from(JSON.stringify({
|
|
DeviceID: 'BOX_001', id: '124', action: 'task', result: 'unconfirm'
|
|
})));
|
|
assert.equal(calls.some((item) =>
|
|
item.sql.includes('INSERT INTO qipai_device_alerts')
|
|
&& item.params.includes('DEVICE_UNCONFIRM')
|
|
), true);
|
|
for (const [id, result, failureCode] of [
|
|
['125', 'busy', 'DEVICE_BUSY'],
|
|
['126', 'fail', 'DEVICE_FAIL']
|
|
]) {
|
|
await service.handle('/devicesend/BOX_001', Buffer.from(JSON.stringify({
|
|
DeviceID: 'BOX_001', id, action: 'task', result
|
|
})));
|
|
assert.equal(calls.some((item) =>
|
|
item.sql.includes('UPDATE qipai_iot_commands')
|
|
&& item.params[0] === 'FAILED'
|
|
&& item.params[2] === failureCode
|
|
), true);
|
|
}
|
|
const commandUpdatesBeforeEvents = calls.filter((item) =>
|
|
item.sql.includes('UPDATE qipai_iot_commands')
|
|
).length;
|
|
for (const eventType of ['magstate', 'taskfinish']) {
|
|
await service.handle('/devicesend/BOX_001', Buffer.from(JSON.stringify({
|
|
DeviceID: 'BOX_001', event: eventType, state: 'close'
|
|
})));
|
|
}
|
|
assert.equal(calls.filter((item) =>
|
|
item.sql.includes('UPDATE qipai_iot_commands')
|
|
).length, commandUpdatesBeforeEvents);
|
|
|
|
const deadLettersBeforeWill = calls.filter((item) =>
|
|
item.sql.includes('qipai_iot_dead_letters')
|
|
).length;
|
|
await service.handle('/devicewill/BOX_001', Buffer.from('close'));
|
|
assert.equal(calls.some((item) =>
|
|
item.sql.includes('UPDATE qipai_devices') && item.params[0] === 'OFFLINE'
|
|
), true);
|
|
assert.equal(calls.filter((item) =>
|
|
item.sql.includes('qipai_iot_dead_letters')
|
|
).length, deadLettersBeforeWill);
|
|
|
|
await service.handle('/devicesend/BOX_001', Buffer.from(JSON.stringify({
|
|
DeviceID: 'BOX_001', id: '127', action: 'task', result: 'vendor-new-code'
|
|
})));
|
|
assert.equal(calls.some((item) =>
|
|
item.sql.includes('qipai_iot_dead_letters')
|
|
&& item.params.includes('UNKNOWN_VENDOR_RESULT')
|
|
), true);
|
|
assert.equal(calls.some((item) =>
|
|
item.sql.includes('UPDATE qipai_iot_commands')
|
|
&& item.params[0] === 'FAILED'
|
|
&& item.params[2] === 'UNKNOWN_VENDOR_RESULT'
|
|
), true);
|
|
|
|
const socketAlertsBeforeFakeFields = calls.filter((item) =>
|
|
item.sql.includes('INSERT INTO qipai_device_alerts')
|
|
).length;
|
|
await service.handle('/devicesend/SOCKET_001', Buffer.from(JSON.stringify({
|
|
DeviceID: 'SOCKET_001', event: 'workInfo', switch: 'on',
|
|
powerW: 3601, temperature: 82, overLoad: true
|
|
})));
|
|
assert.equal(calls.filter((item) =>
|
|
item.sql.includes('INSERT INTO qipai_device_alerts')
|
|
).length, socketAlertsBeforeFakeFields, 'legacy fake fields must not generate alerts');
|
|
|
|
await service.handle('/devicesend/SOCKET_001', Buffer.from(JSON.stringify({
|
|
DeviceID: 'SOCKET_001', read: 'workInfo', onOff: 'on',
|
|
vol: '220.50', cur: '1.250', pow: '275.000', temp: '45.5', energy: '12.340'
|
|
})));
|
|
const workInfoInsert = calls.findLast((item) =>
|
|
item.sql.includes('INSERT INTO qipai_iot_device_events')
|
|
);
|
|
const persistedWorkInfo = JSON.parse(workInfoInsert.params[9]).payload;
|
|
assert.deepEqual({
|
|
switchOn: persistedWorkInfo.switchOn,
|
|
voltage: persistedWorkInfo.voltage,
|
|
current: persistedWorkInfo.current,
|
|
power: persistedWorkInfo.power,
|
|
temperature: persistedWorkInfo.temperature,
|
|
energy: persistedWorkInfo.energy
|
|
}, {
|
|
switchOn: true, voltage: '220.5', current: '1.25', power: '275',
|
|
temperature: '45.5', energy: '12.34'
|
|
});
|
|
|
|
const protectionAlerts = new Map([
|
|
[3, 'SOCKET_PULL_OUT_STOP'], [4, 'SOCKET_CHARGE_FULL_STOP'],
|
|
[5, 'SOCKET_OVERPOWER'], [6, 'SOCKET_OVERCURRENT'],
|
|
[7, 'SOCKET_OVERTEMPERATURE']
|
|
]);
|
|
for (let closeReason = 1; closeReason <= 7; closeReason += 1) {
|
|
const alertCountBefore = calls.filter((item) =>
|
|
item.sql.includes('INSERT INTO qipai_device_alerts')
|
|
).length;
|
|
await service.handle('/devicesend/SOCKET_001', Buffer.from(JSON.stringify({
|
|
DeviceID: 'SOCKET_001', event: 'special', slotNum: 1,
|
|
state: 'off', closeReason, energy: `${closeReason}.0`
|
|
})));
|
|
const alertType = protectionAlerts.get(closeReason);
|
|
if (alertType) {
|
|
assert.equal(calls.some((item) =>
|
|
item.sql.includes('INSERT INTO qipai_device_alerts') && item.params.includes(alertType)
|
|
), true);
|
|
} else {
|
|
assert.equal(calls.filter((item) =>
|
|
item.sql.includes('INSERT INTO qipai_device_alerts')
|
|
).length, alertCountBefore, `closeReason ${closeReason} is only a local operation`);
|
|
}
|
|
}
|
|
|
|
await service.handle('/devicesend/SOCKET_001', Buffer.from(JSON.stringify({
|
|
DeviceID: 'SOCKET_001', read: 'workInfo', temp: '45', temperature: '46'
|
|
})));
|
|
assert.equal(calls.some((item) =>
|
|
item.sql.includes('qipai_iot_dead_letters')
|
|
&& item.params.includes('SOCKET_TEMPERATURE_CONFLICT')
|
|
), true);
|
|
|
|
await assert.rejects(
|
|
() => service.createCommand({
|
|
tenantId: '7', assetId: '51', storeId: '11',
|
|
commandId: '12345678901234', commandType: 'ConctolPower',
|
|
payload: {}, traceId: 'trace'
|
|
}),
|
|
/IOT_COMMAND_ID_INVALID/
|
|
);
|
|
|
|
await service.createCommand({
|
|
tenantId: '7', assetId: '51', storeId: '11', commandId: '128',
|
|
commandType: 'CtrlDevice', traceId: 'secret-test',
|
|
payload: {
|
|
action: 'CtrlDevice', subtype: '14', subID: 'SUB001',
|
|
order: 'setkey', value: '123456'
|
|
}
|
|
});
|
|
const secretCommandInsert = calls.findLast((item) =>
|
|
item.sql.includes('INSERT INTO qipai_iot_commands')
|
|
);
|
|
assert.equal(secretCommandInsert.params[7].includes('123456'), false);
|
|
assert.equal(secretCommandInsert.params[7].includes('valueHash'), true);
|
|
|
|
await service.createCommand({
|
|
tenantId: '7', assetId: '52', storeId: '11', commandId: '129',
|
|
commandType: 'setReturnKey', traceId: 'socket-secret-test',
|
|
payload: { action: 'setReturnKey', id: '129', old: 'old-secret', new: 'new-secret' }
|
|
});
|
|
const socketSecretInsert = calls.findLast((item) =>
|
|
item.sql.includes('INSERT INTO qipai_iot_commands')
|
|
);
|
|
assert.equal(socketSecretInsert.params[7].includes('old-secret'), false);
|
|
assert.equal(socketSecretInsert.params[7].includes('new-secret'), false);
|
|
assert.equal(socketSecretInsert.params[7].includes('oldHash'), true);
|
|
assert.equal(socketSecretInsert.params[7].includes('newHash'), true);
|
|
|
|
const commandCalls = [];
|
|
const commandService = new DeviceCommandService({
|
|
async createCommand(input) { commandCalls.push(['create', input]); },
|
|
async markPublished(tenantId, commandId) {
|
|
commandCalls.push(['published', tenantId, commandId]);
|
|
},
|
|
async markPublishFailed() { throw new Error('unexpected publish failure'); }
|
|
}, {
|
|
async publishDeviceCommand(deviceId, payloadText) {
|
|
commandCalls.push(['mqtt', deviceId, JSON.parse(payloadText)]);
|
|
}
|
|
});
|
|
const issued = await commandService.issue({
|
|
tenantId: '7', assetId: '51', deviceId: 'BOX_001', storeId: '11',
|
|
commandType: 'ConctolPower',
|
|
payloadFactory: (id) => control.controlPower({ id, slot1: 'on' }),
|
|
traceId: 'trace'
|
|
});
|
|
assert.equal(issued.status, 'PUBLISHED');
|
|
assert.match(issued.commandId, /^\d{13}$/);
|
|
assert.equal(commandCalls[0][0], 'create');
|
|
assert.equal(commandCalls[1][0], 'mqtt');
|
|
assert.equal(commandCalls[2][0], 'published');
|
|
|
|
console.log('PASS: M06-C/E-R1 exact wire, normalized events, ACKs and QoS 1 dedup work.');
|