feat: Use Vitest for testing (#25284)

Co-authored-by: Koen Kanters <koenkanters94@gmail.com>
2026-08-28 05:24:29 +00:00 · 2024-12-22 20:19:45 +01:00
parent 5d059b7bcb
commit 06f44533af
51 changed files with 2606 additions and 4771 deletions
@@ -1,6 +1,6 @@
 import * as data from '../mocks/data';
 import {mockLogger} from '../mocks/logger';
-import {mockMQTT, events as mockMQTTEvents} from '../mocks/mqtt';
+import {mockMQTTEndAsync, events as mockMQTTEvents, mockMQTTPublishAsync} from '../mocks/mqtt';
 import {flushPromises} from '../mocks/utils';
 import {devices, mockController as mockZHController, returnDevices} from '../mocks/zigbeeHerdsman';

@@ -18,15 +18,15 @@ describe('Extension: ExternalExtensions', () => {
    let controller: Controller;
    const mockBasePath = path.join(data.mockDir, BASE_DIR);

-    const existsSyncSpy = jest.spyOn(fs, 'existsSync');
-    const readdirSyncSpy = jest.spyOn(fs, 'readdirSync');
-    const mkdirSyncSpy = jest.spyOn(fs, 'mkdirSync');
-    const rmSyncSpy = jest.spyOn(fs, 'rmSync');
-    const writeFileSyncSpy = jest.spyOn(fs, 'writeFileSync');
+    const existsSyncSpy = vi.spyOn(fs, 'existsSync');
+    const readdirSyncSpy = vi.spyOn(fs, 'readdirSync');
+    const mkdirSyncSpy = vi.spyOn(fs, 'mkdirSync');
+    const rmSyncSpy = vi.spyOn(fs, 'rmSync');
+    const writeFileSyncSpy = vi.spyOn(fs, 'writeFileSync');

    const mocksClear = [
-        mockMQTT.endAsync,
-        mockMQTT.publishAsync,
+        mockMQTTEndAsync,
+        mockMQTTPublishAsync,
        mockLogger.debug,
        mockLogger.error,
        mockZHController.stop,
@@ -46,12 +46,21 @@ describe('Extension: ExternalExtensions', () => {
        return fs.readFileSync(path.join(__dirname, '..', 'assets', BASE_DIR, fileName), 'utf8');
    };

+    const resetExtension = async (): Promise<void> => {
+        await controller.enableDisableExtension(false, 'ExternalExtensions');
+        await controller.enableDisableExtension(true, 'ExternalExtensions');
+    };
+
    beforeAll(async () => {
-        jest.useFakeTimers();
+        vi.useFakeTimers();
+
+        controller = new Controller(vi.fn(), vi.fn());
+        await controller.start();
+        await flushPromises();
    });

    afterAll(async () => {
-        jest.useRealTimers();
+        vi.useRealTimers();
    });

    beforeEach(async () => {
@@ -60,72 +69,80 @@ describe('Extension: ExternalExtensions', () => {
        data.writeDefaultState();
        settings.reRead();
        returnDevices.splice(0);
-
-        controller = new Controller(jest.fn(), jest.fn());
    });

    afterEach(() => {
        fs.rmSync(mockBasePath, {recursive: true, force: true});
    });

-    it('loads nothing from folder', async () => {
-        await controller.start();
-        await flushPromises();
-
-        expect(existsSyncSpy).toHaveBeenCalledWith(mockBasePath);
-        expect(readdirSyncSpy).not.toHaveBeenCalledWith(mockBasePath);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/extensions', stringify([]), {retain: true, qos: 0});
-    });
-
-    it('loads from folder', async () => {
-        useAssets();
-
-        await controller.start();
-        await flushPromises();
-
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/example2/extension', 'call2 from constructor', {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/example2/extension', 'call2 from start', {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/example/extension', 'call from constructor', {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/example/extension', 'call from start', {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
-            'zigbee2mqtt/bridge/extensions',
-            stringify([
-                {name: 'example2Extension.js', code: getFileCode('example2Extension.js')},
-                {name: 'exampleExtension.js', code: getFileCode('exampleExtension.js')},
-            ]),
-            {retain: true, qos: 0},
-        );
-    });
-
-    it('saves and removes from MQTT', async () => {
-        const extensionName = 'foo.js';
-        const extensionCode = getFileCode('exampleExtension.js');
-        const extensionFilePath = path.join(mockBasePath, extensionName);
-
-        await controller.start();
-        await flushPromises();
-        mocksClear.forEach((m) => m.mockClear());
-
-        //-- SAVE
-        mockMQTTEvents.message('zigbee2mqtt/bridge/request/extension/save', stringify({name: extensionName, code: extensionCode}));
-        await flushPromises();
-
-        expect(mkdirSyncSpy).toHaveBeenCalledWith(mockBasePath, {recursive: true});
-        expect(writeFileSyncSpy).toHaveBeenCalledWith(extensionFilePath, extensionCode, 'utf8');
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/example/extension', 'call from constructor', {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/example/extension', 'call from start', {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/extensions', stringify([{name: extensionName, code: extensionCode}]), {
-            retain: true,
-            qos: 0,
+    describe('from folder', () => {
+        beforeEach(async () => {
+            controller = new Controller(vi.fn(), vi.fn());
        });

-        //-- REMOVE
-        mockMQTTEvents.message('zigbee2mqtt/bridge/request/extension/remove', stringify({name: extensionName}));
-        await flushPromises();
+        it('loads nothing', async () => {
+            await controller.start();
+            await flushPromises();

-        expect(rmSyncSpy).toHaveBeenCalledWith(extensionFilePath, {force: true});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/example/extension', 'call from stop', {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/extensions', stringify([]), {retain: true, qos: 0});
+            expect(existsSyncSpy).toHaveBeenCalledWith(mockBasePath);
+            expect(readdirSyncSpy).not.toHaveBeenCalledWith(mockBasePath);
+            expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/extensions', stringify([]), {retain: true, qos: 0});
+        });
+
+        it('loads extensions', async () => {
+            useAssets();
+
+            await controller.start();
+            await flushPromises();
+
+            expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/example2/extension', 'call2 from constructor', {retain: false, qos: 0});
+            expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/example2/extension', 'call2 from start', {retain: false, qos: 0});
+            expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/example/extension', 'call from constructor', {retain: false, qos: 0});
+            expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/example/extension', 'call from start', {retain: false, qos: 0});
+            expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+                'zigbee2mqtt/bridge/extensions',
+                stringify([
+                    {name: 'example2Extension.js', code: getFileCode('example2Extension.js')},
+                    {name: 'exampleExtension.js', code: getFileCode('exampleExtension.js')},
+                ]),
+                {retain: true, qos: 0},
+            );
+        });
+
+        it('saves and removes from MQTT', async () => {
+            const extensionName = 'foo.js';
+            const extensionCode = getFileCode('exampleExtension.js');
+            const extensionFilePath = path.join(mockBasePath, extensionName);
+
+            await controller.start();
+            await flushPromises();
+            mocksClear.forEach((m) => m.mockClear());
+
+            //-- SAVE
+            mockMQTTEvents.message('zigbee2mqtt/bridge/request/extension/save', stringify({name: extensionName, code: extensionCode}));
+            await flushPromises();
+
+            expect(mkdirSyncSpy).toHaveBeenCalledWith(mockBasePath, {recursive: true});
+            expect(writeFileSyncSpy).toHaveBeenCalledWith(extensionFilePath, extensionCode, 'utf8');
+            expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/example/extension', 'call from constructor', {retain: false, qos: 0});
+            expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/example/extension', 'call from start', {retain: false, qos: 0});
+            expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+                'zigbee2mqtt/bridge/extensions',
+                stringify([{name: extensionName, code: extensionCode}]),
+                {
+                    retain: true,
+                    qos: 0,
+                },
+            );
+
+            //-- REMOVE
+            mockMQTTEvents.message('zigbee2mqtt/bridge/request/extension/remove', stringify({name: extensionName}));
+            await flushPromises();
+
+            expect(rmSyncSpy).toHaveBeenCalledWith(extensionFilePath, {force: true});
+            expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/example/extension', 'call from stop', {retain: false, qos: 0});
+            expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/extensions', stringify([]), {retain: true, qos: 0});
+        });
    });

    it('returns error on invalid code', async () => {
@@ -133,14 +150,13 @@ describe('Extension: ExternalExtensions', () => {
        const extensionCode = 'definetly not a correct javascript code';
        const extensionFilePath = path.join(mockBasePath, extensionName);

-        await controller.start();
-        await flushPromises();
+        await resetExtension();
        mocksClear.forEach((m) => m.mockClear());

        mockMQTTEvents.message('zigbee2mqtt/bridge/request/extension/save', stringify({name: extensionName, code: extensionCode}));
        await flushPromises();

-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
            'zigbee2mqtt/bridge/response/extension/save',
            expect.stringContaining(`"error":"${extensionName} contains invalid code`),
            {retain: false, qos: 0},
@@ -152,14 +168,13 @@ describe('Extension: ExternalExtensions', () => {
        const converterName = 'invalid.js';
        const converterFilePath = path.join(mockBasePath, converterName);

-        await controller.start();
-        await flushPromises();
+        await resetExtension();
        mocksClear.forEach((m) => m.mockClear());

        mockMQTTEvents.message('zigbee2mqtt/bridge/request/extension/remove', stringify({name: converterName}));
        await flushPromises();

-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
            'zigbee2mqtt/bridge/response/extension/remove',
            stringify({data: {}, status: 'error', error: `${converterName} (${converterFilePath}) doesn't exists`}),
            {retain: false, qos: 0},
@@ -168,14 +183,13 @@ describe('Extension: ExternalExtensions', () => {
    });

    it('handles invalid payloads', async () => {
-        await controller.start();
-        await flushPromises();
+        await resetExtension();
        mocksClear.forEach((m) => m.mockClear());

        mockMQTTEvents.message('zigbee2mqtt/bridge/request/extension/save', stringify({name: 'test.js', transaction: 1 /* code */}));
        await flushPromises();

-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
            'zigbee2mqtt/bridge/response/extension/save',
            stringify({data: {}, status: 'error', error: `Invalid payload`, transaction: 1}),
            {retain: false, qos: 0},
@@ -184,7 +198,7 @@ describe('Extension: ExternalExtensions', () => {
        mockMQTTEvents.message('zigbee2mqtt/bridge/request/extension/remove', stringify({namex: 'test.js', transaction: 2}));
        await flushPromises();

-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
            'zigbee2mqtt/bridge/response/extension/remove',
            stringify({data: {}, status: 'error', error: `Invalid payload`, transaction: 2}),
            {retain: false, qos: 0},