matterbridge-test 2.0.0-dev-20251025-d87e883 → 2.0.0-dev-20251026-dbfaf33

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/npm-shrinkwrap.json +2 -2
  2. package/package.json +1 -1
  3. package/dist/jestHelpers.js +0 -313
package/npm-shrinkwrap.json CHANGED
@@ -1,12 +1,12 @@
1
1
  {
2
2
  "name": "matterbridge-test",
3
- "version": "2.0.0-dev-20251025-d87e883",
3
+ "version": "2.0.0-dev-20251026-dbfaf33",
4
4
  "lockfileVersion": 3,
5
5
  "requires": true,
6
6
  "packages": {
7
7
  "": {
8
8
  "name": "matterbridge-test",
9
- "version": "2.0.0-dev-20251025-d87e883",
9
+ "version": "2.0.0-dev-20251026-dbfaf33",
10
10
  "license": "Apache-2.0",
11
11
  "dependencies": {
12
12
  "node-ansi-logger": "3.1.1",
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "matterbridge-test",
3
- "version": "2.0.0-dev-20251025-d87e883",
3
+ "version": "2.0.0-dev-20251026-dbfaf33",
4
4
  "description": "Matterbridge test plugin",
5
5
  "author": "https://github.com/Luligu",
6
6
  "license": "Apache-2.0",
package/dist/jestHelpers.js DELETED
@@ -1,313 +0,0 @@
1
- import { rmSync } from 'node:fs';
2
- import { inspect } from 'node:util';
3
- import path from 'node:path';
4
- import { jest } from '@jest/globals';
5
- import { DeviceTypeId, Endpoint, Environment, MdnsService, ServerNode, ServerNodeStore, VendorId, LogFormat as MatterLogFormat, LogLevel as MatterLogLevel, Lifecycle, } from 'matterbridge/matter';
6
- import { RootEndpoint, AggregatorEndpoint } from 'matterbridge/matter/endpoints';
7
- import { AnsiLogger } from 'matterbridge/logger';
8
- import { MATTER_STORAGE_NAME, Matterbridge } from 'matterbridge';
9
- export let loggerLogSpy;
10
- export let consoleLogSpy;
11
- export let consoleDebugSpy;
12
- export let consoleInfoSpy;
13
- export let consoleWarnSpy;
14
- export let consoleErrorSpy;
15
- export const addBridgedEndpointSpy = jest.spyOn(Matterbridge.prototype, 'addBridgedEndpoint');
16
- export const removeBridgedEndpointSpy = jest.spyOn(Matterbridge.prototype, 'removeBridgedEndpoint');
17
- export const removeAllBridgedEndpointSpy = jest.spyOn(Matterbridge.prototype, 'removeAllBridgedEndpoints');
18
- export function setupTest(name, debug = false) {
19
- expect(name).toBeDefined();
20
- expect(typeof name).toBe('string');
21
- expect(name.length).toBeGreaterThanOrEqual(4);
22
- rmSync(path.join('jest', name), { recursive: true, force: true });
23
- if (debug) {
24
- loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
25
- consoleLogSpy = jest.spyOn(console, 'log');
26
- consoleDebugSpy = jest.spyOn(console, 'debug');
27
- consoleInfoSpy = jest.spyOn(console, 'info');
28
- consoleWarnSpy = jest.spyOn(console, 'warn');
29
- consoleErrorSpy = jest.spyOn(console, 'error');
30
- }
31
- else {
32
- loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log').mockImplementation(() => { });
33
- consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
34
- consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
35
- consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
36
- consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
37
- consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
38
- }
39
- }
40
- export function setDebug(debug) {
41
- if (debug) {
42
- loggerLogSpy.mockRestore();
43
- consoleLogSpy.mockRestore();
44
- consoleDebugSpy.mockRestore();
45
- consoleInfoSpy.mockRestore();
46
- consoleWarnSpy.mockRestore();
47
- consoleErrorSpy.mockRestore();
48
- loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log');
49
- consoleLogSpy = jest.spyOn(console, 'log');
50
- consoleDebugSpy = jest.spyOn(console, 'debug');
51
- consoleInfoSpy = jest.spyOn(console, 'info');
52
- consoleWarnSpy = jest.spyOn(console, 'warn');
53
- consoleErrorSpy = jest.spyOn(console, 'error');
54
- }
55
- else {
56
- loggerLogSpy = jest.spyOn(AnsiLogger.prototype, 'log').mockImplementation(() => { });
57
- consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
58
- consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
59
- consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation(() => { });
60
- consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
61
- consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
62
- }
63
- }
64
- export async function createMatterbridgeEnvironment(name) {
65
- const matterbridge = await Matterbridge.loadInstance(false);
66
- expect(matterbridge).toBeDefined();
67
- expect(matterbridge).toBeInstanceOf(Matterbridge);
68
- matterbridge.matterbridgeVersion = '3.3.0';
69
- matterbridge.bridgeMode = 'bridge';
70
- matterbridge.rootDirectory = path.join('jest', name);
71
- matterbridge.homeDirectory = path.join('jest', name);
72
- matterbridge.matterbridgeDirectory = path.join('jest', name, '.matterbridge');
73
- matterbridge.matterbridgePluginDirectory = path.join('jest', name, 'Matterbridge');
74
- matterbridge.matterbridgeCertDirectory = path.join('jest', name, '.mattercert');
75
- matterbridge.environment = createTestEnvironment(name);
76
- expect(matterbridge.environment).toBeDefined();
77
- expect(matterbridge.environment).toBeInstanceOf(Environment);
78
- return matterbridge;
79
- }
80
- export async function startMatterbridgeEnvironment(matterbridge, port = 5540) {
81
- await matterbridge.startMatterStorage();
82
- expect(matterbridge.matterStorageService).toBeDefined();
83
- expect(matterbridge.matterStorageManager).toBeDefined();
84
- expect(matterbridge.matterbridgeContext).toBeDefined();
85
- const server = await matterbridge.createServerNode(matterbridge.matterbridgeContext, port);
86
- expect(server).toBeDefined();
87
- expect(server).toBeDefined();
88
- expect(server.lifecycle.isReady).toBeTruthy();
89
- matterbridge.serverNode = server;
90
- const aggregator = await matterbridge.createAggregatorNode(matterbridge.matterbridgeContext);
91
- expect(aggregator).toBeDefined();
92
- matterbridge.aggregatorNode = aggregator;
93
- expect(await server.add(aggregator)).toBeDefined();
94
- expect(server.parts.has(aggregator.id)).toBeTruthy();
95
- expect(server.parts.has(aggregator)).toBeTruthy();
96
- expect(aggregator.lifecycle.isReady).toBeTruthy();
97
- expect(server.lifecycle.isOnline).toBeFalsy();
98
- await new Promise((resolve) => {
99
- server.lifecycle.online.on(async () => {
100
- resolve();
101
- });
102
- server.start();
103
- });
104
- expect(server.lifecycle.isReady).toBeTruthy();
105
- expect(server.lifecycle.isOnline).toBeTruthy();
106
- expect(server.lifecycle.isCommissioned).toBeFalsy();
107
- expect(server.lifecycle.isPartsReady).toBeTruthy();
108
- expect(server.lifecycle.hasId).toBeTruthy();
109
- expect(server.lifecycle.hasNumber).toBeTruthy();
110
- expect(aggregator.lifecycle.isReady).toBeTruthy();
111
- expect(aggregator.lifecycle.isInstalled).toBeTruthy();
112
- expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
113
- expect(aggregator.lifecycle.hasId).toBeTruthy();
114
- expect(aggregator.lifecycle.hasNumber).toBeTruthy();
115
- await flushAsync();
116
- return [server, aggregator];
117
- }
118
- export async function stopMatterbridgeEnvironment(matterbridge, server, aggregator) {
119
- expect(matterbridge).toBeDefined();
120
- expect(server).toBeDefined();
121
- expect(aggregator).toBeDefined();
122
- await flushAllEndpointNumberPersistence(server);
123
- await assertAllEndpointNumbersPersisted(server);
124
- expect(server.lifecycle.isReady).toBeTruthy();
125
- expect(server.lifecycle.isOnline).toBeTruthy();
126
- await server.close();
127
- expect(server.lifecycle.isReady).toBeTruthy();
128
- expect(server.lifecycle.isOnline).toBeFalsy();
129
- await server.env.get(MdnsService)[Symbol.asyncDispose]();
130
- await matterbridge.stopMatterStorage();
131
- expect(matterbridge.matterStorageService).not.toBeDefined();
132
- expect(matterbridge.matterStorageManager).not.toBeDefined();
133
- expect(matterbridge.matterbridgeContext).not.toBeDefined();
134
- await flushAsync();
135
- }
136
- export async function destroyMatterbridgeEnvironment(matterbridge) {
137
- await matterbridge.destroyInstance(10);
138
- Matterbridge.instance = undefined;
139
- }
140
- export function createTestEnvironment(name) {
141
- expect(name).toBeDefined();
142
- expect(typeof name).toBe('string');
143
- expect(name.length).toBeGreaterThanOrEqual(4);
144
- rmSync(path.join('jest', name), { recursive: true, force: true });
145
- const environment = Environment.default;
146
- environment.vars.set('log.level', MatterLogLevel.DEBUG);
147
- environment.vars.set('log.format', MatterLogFormat.ANSI);
148
- environment.vars.set('path.root', path.join('jest', name, '.matterbridge', MATTER_STORAGE_NAME));
149
- environment.vars.set('runtime.signals', false);
150
- environment.vars.set('runtime.exitcode', false);
151
- new MdnsService(environment);
152
- return environment;
153
- }
154
- export async function flushAsync(ticks = 3, microTurns = 10, pause = 250) {
155
- for (let i = 0; i < ticks; i++)
156
- await new Promise((resolve) => setImmediate(resolve));
157
- for (let i = 0; i < microTurns; i++)
158
- await Promise.resolve();
159
- if (pause)
160
- await new Promise((resolve) => setTimeout(resolve, pause));
161
- }
162
- export async function flushAllEndpointNumberPersistence(targetServer, rounds = 2) {
163
- const nodeStore = targetServer.env.get(ServerNodeStore);
164
- for (let i = 0; i < rounds; i++) {
165
- await new Promise((resolve) => setImmediate(resolve));
166
- await nodeStore.endpointStores.close();
167
- }
168
- }
169
- function collectAllEndpoints(root) {
170
- const list = [];
171
- const walk = (ep) => {
172
- list.push(ep);
173
- if (ep.parts) {
174
- for (const child of ep.parts) {
175
- walk(child);
176
- }
177
- }
178
- };
179
- walk(root);
180
- return list;
181
- }
182
- export async function assertAllEndpointNumbersPersisted(targetServer) {
183
- const nodeStore = targetServer.env.get(ServerNodeStore);
184
- await nodeStore.endpointStores.close();
185
- const all = collectAllEndpoints(targetServer);
186
- for (const ep of all) {
187
- const store = nodeStore.storeForEndpoint(ep);
188
- if (ep.maybeNumber === 0) {
189
- expect(store.number ?? 0).toBe(0);
190
- }
191
- else {
192
- expect(store.number).toBeGreaterThan(0);
193
- }
194
- }
195
- return all.length;
196
- }
197
- export async function startServerNode(name, port, environment) {
198
- const server = await ServerNode.create({
199
- id: name + 'ServerNode',
200
- environment: environment,
201
- productDescription: {
202
- name: name + 'ServerNode',
203
- deviceType: DeviceTypeId(RootEndpoint.deviceType),
204
- vendorId: VendorId(0xfff1),
205
- productId: 0x8000,
206
- },
207
- basicInformation: {
208
- vendorId: VendorId(0xfff1),
209
- vendorName: 'Matterbridge',
210
- productId: 0x8000,
211
- productName: 'Matterbridge ' + name,
212
- nodeLabel: name + 'ServerNode',
213
- hardwareVersion: 1,
214
- softwareVersion: 1,
215
- reachable: true,
216
- },
217
- network: {
218
- port,
219
- },
220
- });
221
- expect(server).toBeDefined();
222
- expect(server.lifecycle.isReady).toBeTruthy();
223
- const aggregator = new Endpoint(AggregatorEndpoint, {
224
- id: name + 'AggregatorNode',
225
- });
226
- expect(aggregator).toBeDefined();
227
- await server.add(aggregator);
228
- expect(server.parts.has(aggregator.id)).toBeTruthy();
229
- expect(server.parts.has(aggregator)).toBeTruthy();
230
- expect(aggregator.lifecycle.isReady).toBeTruthy();
231
- expect(server.lifecycle.isOnline).toBeFalsy();
232
- await new Promise((resolve) => {
233
- server.lifecycle.online.on(async () => {
234
- resolve();
235
- });
236
- server.start();
237
- });
238
- expect(server.lifecycle.isReady).toBeTruthy();
239
- expect(server.lifecycle.isOnline).toBeTruthy();
240
- expect(server.lifecycle.isCommissioned).toBeFalsy();
241
- expect(server.lifecycle.isPartsReady).toBeTruthy();
242
- expect(server.lifecycle.hasId).toBeTruthy();
243
- expect(server.lifecycle.hasNumber).toBeTruthy();
244
- expect(aggregator.lifecycle.isReady).toBeTruthy();
245
- expect(aggregator.lifecycle.isInstalled).toBeTruthy();
246
- expect(aggregator.lifecycle.isPartsReady).toBeTruthy();
247
- expect(aggregator.lifecycle.hasId).toBeTruthy();
248
- expect(aggregator.lifecycle.hasNumber).toBeTruthy();
249
- await flushAsync();
250
- return [server, aggregator];
251
- }
252
- export async function stopServerNode(server) {
253
- await flushAllEndpointNumberPersistence(server);
254
- await assertAllEndpointNumbersPersisted(server);
255
- expect(server).toBeDefined();
256
- expect(server.lifecycle.isReady).toBeTruthy();
257
- expect(server.lifecycle.isOnline).toBeTruthy();
258
- await server.close();
259
- expect(server.lifecycle.isReady).toBeTruthy();
260
- expect(server.lifecycle.isOnline).toBeFalsy();
261
- await server.env.get(MdnsService)[Symbol.asyncDispose]();
262
- await flushAsync();
263
- }
264
- export async function addDevice(owner, device, pause = 10) {
265
- expect(owner).toBeDefined();
266
- expect(device).toBeDefined();
267
- expect(owner.lifecycle.isReady).toBeTruthy();
268
- expect(owner.construction.status).toBe(Lifecycle.Status.Active);
269
- expect(owner.lifecycle.isPartsReady).toBeTruthy();
270
- try {
271
- await owner.add(device);
272
- }
273
- catch (error) {
274
- const errorMessage = error instanceof Error ? error.message : error;
275
- const errorInspect = inspect(error, { depth: 10 });
276
- console.error(`Error adding device ${device.maybeId}.${device.maybeNumber}: ${errorMessage}\nstack: ${errorInspect}`);
277
- return false;
278
- }
279
- expect(owner.parts.has(device)).toBeTruthy();
280
- expect(owner.lifecycle.isPartsReady).toBeTruthy();
281
- expect(device.lifecycle.isReady).toBeTruthy();
282
- expect(device.lifecycle.isInstalled).toBeTruthy();
283
- expect(device.lifecycle.hasId).toBeTruthy();
284
- expect(device.lifecycle.hasNumber).toBeTruthy();
285
- expect(device.construction.status).toBe(Lifecycle.Status.Active);
286
- await flushAsync(undefined, undefined, pause);
287
- return true;
288
- }
289
- export async function deleteDevice(owner, device, pause = 10) {
290
- expect(owner).toBeDefined();
291
- expect(device).toBeDefined();
292
- expect(owner.lifecycle.isReady).toBeTruthy();
293
- expect(owner.construction.status).toBe(Lifecycle.Status.Active);
294
- expect(owner.lifecycle.isPartsReady).toBeTruthy();
295
- try {
296
- await device.delete();
297
- }
298
- catch (error) {
299
- const errorMessage = error instanceof Error ? error.message : error;
300
- const errorInspect = inspect(error, { depth: 10 });
301
- console.error(`Error deleting device ${device.maybeId}.${device.maybeNumber}: ${errorMessage}\nstack: ${errorInspect}`);
302
- return false;
303
- }
304
- expect(owner.parts.has(device)).toBeFalsy();
305
- expect(owner.lifecycle.isPartsReady).toBeTruthy();
306
- expect(device.lifecycle.isReady).toBeFalsy();
307
- expect(device.lifecycle.isInstalled).toBeFalsy();
308
- expect(device.lifecycle.hasId).toBeTruthy();
309
- expect(device.lifecycle.hasNumber).toBeTruthy();
310
- expect(device.construction.status).toBe(Lifecycle.Status.Destroyed);
311
- await flushAsync(undefined, undefined, pause);
312
- return true;
313
- }