const assert = require('assert');
|
const { EventEmitter } = require('events');
|
const { AliyunService } = require('../aliyun-service');
|
|
class MockIotDevice extends EventEmitter {
|
constructor({ autoConnect = true } = {}) {
|
super();
|
this.lastPayload = null;
|
|
if (autoConnect) {
|
setImmediate(() => {
|
this.emit('connect');
|
});
|
}
|
}
|
|
postProps(payload, callback) {
|
this.lastPayload = payload;
|
callback({ message: 'success' });
|
}
|
}
|
|
function createLogger() {
|
return {
|
infoMessages: [],
|
warnMessages: [],
|
errorMessages: [],
|
info(message) {
|
this.infoMessages.push(message);
|
},
|
warn(message) {
|
this.warnMessages.push(message);
|
},
|
error(message) {
|
this.errorMessages.push(message);
|
},
|
};
|
}
|
|
function createService({ logger = console, deviceFactory, fetchImpl } = {}) {
|
return new AliyunService({
|
enabled: true,
|
tupleApiBaseUrl: 'https://things.icoldchain.cn',
|
tupleApiPath: '/device/info/getAliyunDeviceSecret',
|
autoRegister: true,
|
registerRetryMs: 60000,
|
connectTimeoutMs: 5000,
|
closeLogThrottleMs: 60000,
|
}, logger, {
|
fetchImpl: fetchImpl || (async (_url, options = {}) => ({
|
ok: true,
|
text: async () => JSON.stringify({
|
data: {
|
productKey: 'pk-demo',
|
deviceName: 'JHM-001',
|
deviceSecret: 'secret-demo',
|
requestBody: options.body || '',
|
},
|
}),
|
})),
|
aliyunSdk: {
|
device: deviceFactory || (() => new MockIotDevice()),
|
},
|
});
|
}
|
|
describe('AliyunService', () => {
|
it('adds suedtime into aliyun payload', () => {
|
const service = createService();
|
const payload = service.buildPayload({ F: 37.5 });
|
|
assert.strictEqual(payload.F, 37.5);
|
assert.match(payload.suedtime, /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
|
});
|
|
it('uses deviceId to request tuple and publish the minimal payload', async () => {
|
let requestBody = '';
|
let mockDevice = null;
|
const service = new AliyunService({
|
enabled: true,
|
tupleApiBaseUrl: 'https://things.icoldchain.cn',
|
tupleApiPath: '/device/info/getAliyunDeviceSecret',
|
autoRegister: true,
|
registerRetryMs: 60000,
|
connectTimeoutMs: 5000,
|
}, console, {
|
fetchImpl: async (_url, options) => {
|
requestBody = options.body;
|
return {
|
ok: true,
|
text: async () => JSON.stringify({
|
data: {
|
productKey: 'pk-demo',
|
deviceName: 'JHM-001',
|
deviceSecret: 'secret-demo',
|
},
|
}),
|
};
|
},
|
aliyunSdk: {
|
device: () => {
|
mockDevice = new MockIotDevice();
|
return mockDevice;
|
},
|
},
|
});
|
|
service.start();
|
const result = await service.publish({ deviceId: 'JHM-001', ip: '127.0.0.1' }, { F: 37.5 });
|
|
assert.strictEqual(result.ok, true);
|
assert.match(requestBody, /deviceName=JHM-001/);
|
assert.strictEqual(mockDevice.lastPayload.F, 37.5);
|
assert.match(mockDevice.lastPayload.suedtime, /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
|
});
|
|
it('suppresses repeated close logs and formats sdk errors clearly', async () => {
|
let mockDevice = null;
|
const logger = createLogger();
|
const service = createService({
|
logger,
|
deviceFactory: () => {
|
mockDevice = new MockIotDevice();
|
return mockDevice;
|
},
|
});
|
|
service.start();
|
await service.publish({ deviceId: 'JHM-001', ip: '127.0.0.1' }, { F: 37.5 });
|
|
mockDevice.emit('close');
|
mockDevice.emit('close');
|
mockDevice.emit('error', [new Error('socket reset')]);
|
|
assert.strictEqual(logger.infoMessages.filter((message) => message.includes('连接关闭')).length, 1);
|
assert.strictEqual(logger.errorMessages.some((message) => message.includes('socket reset')), true);
|
assert.strictEqual(logger.errorMessages.some((message) => message.includes('undefined')), false);
|
});
|
|
it('reuses the same sdk device after reconnect', async () => {
|
let createCount = 0;
|
let mockDevice = null;
|
const logger = createLogger();
|
const service = createService({
|
logger,
|
deviceFactory: () => {
|
createCount += 1;
|
mockDevice = new MockIotDevice();
|
return mockDevice;
|
},
|
});
|
|
service.start();
|
await service.publish({ deviceId: 'JHM-001', ip: '127.0.0.1' }, { F: 37.5 });
|
|
mockDevice.emit('close');
|
mockDevice.emit('reconnect');
|
mockDevice.emit('connect');
|
|
const result = await service.publish({ deviceId: 'JHM-001', ip: '127.0.0.1' }, { G: 0 });
|
|
assert.strictEqual(result.ok, true);
|
assert.strictEqual(createCount, 1);
|
assert.strictEqual(logger.infoMessages.some((message) => message.includes('正在重连')), true);
|
assert.strictEqual(logger.infoMessages.some((message) => message.includes('重新连接成功')), true);
|
});
|
|
it('does not create duplicate sdk connections while waiting for reconnect', async () => {
|
let createCount = 0;
|
let mockDevice = null;
|
const logger = createLogger();
|
const service = createService({
|
logger,
|
deviceFactory: () => {
|
createCount += 1;
|
mockDevice = new MockIotDevice();
|
return mockDevice;
|
},
|
});
|
|
service.start();
|
await service.publish({ deviceId: 'JHM-001', ip: '127.0.0.1' }, { F: 37.5 });
|
|
mockDevice.emit('close');
|
|
const publishPromise1 = service.publish({ deviceId: 'JHM-001', ip: '127.0.0.1' }, { B: 0.25 });
|
const publishPromise2 = service.publish({ deviceId: 'JHM-001', ip: '127.0.0.1' }, { D: 320 });
|
|
await new Promise((resolve) => setTimeout(resolve, 30));
|
assert.strictEqual(createCount, 1);
|
assert.strictEqual(logger.infoMessages.some((message) => message.includes('等待现有设备连接恢复')), true);
|
|
mockDevice.emit('connect');
|
const [result1, result2] = await Promise.all([publishPromise1, publishPromise2]);
|
|
assert.strictEqual(result1.ok, true);
|
assert.strictEqual(result2.ok, true);
|
assert.strictEqual(createCount, 1);
|
});
|
|
it('deduplicates tuple requests and initial device creation during the first burst', async () => {
|
let fetchCount = 0;
|
let createCount = 0;
|
let mockDevice = null;
|
const logger = createLogger();
|
const service = createService({
|
logger,
|
fetchImpl: async () => {
|
fetchCount += 1;
|
await new Promise((resolve) => setTimeout(resolve, 50));
|
return {
|
ok: true,
|
text: async () => JSON.stringify({
|
data: {
|
productKey: 'pk-demo',
|
deviceName: 'JHM-001',
|
deviceSecret: 'secret-demo',
|
},
|
}),
|
};
|
},
|
deviceFactory: () => {
|
createCount += 1;
|
mockDevice = new MockIotDevice({ autoConnect: false });
|
return mockDevice;
|
},
|
});
|
|
service.start();
|
|
const publishPromise1 = service.publish({ deviceId: 'JHM-001', ip: '127.0.0.1' }, { H: 1 });
|
const publishPromise2 = service.publish({ deviceId: 'JHM-001', ip: '127.0.0.1' }, { o: 1 });
|
const publishPromise3 = service.publish({ deviceId: 'JHM-001', ip: '127.0.0.1' }, { J: 62 });
|
|
await new Promise((resolve) => setTimeout(resolve, 120));
|
|
assert.strictEqual(fetchCount, 1);
|
assert.strictEqual(createCount, 1);
|
assert.strictEqual(logger.infoMessages.some((message) => message.includes('复用三元组请求中的会话')), true);
|
assert.strictEqual(logger.infoMessages.filter((message) => message.includes('开始创建设备连接')).length, 1);
|
|
mockDevice.emit('connect');
|
const results = await Promise.all([publishPromise1, publishPromise2, publishPromise3]);
|
|
assert.deepStrictEqual(results.map((item) => item.ok), [true, true, true]);
|
assert.strictEqual(fetchCount, 1);
|
assert.strictEqual(createCount, 1);
|
});
|
});
|
