feat: Use Vitest for testing (#25284)

Co-authored-by: Koen Kanters <koenkanters94@gmail.com>

test/extensions/groups.test.ts

@@ -1,6 +1,6 @@
 import * as data from '../mocks/data';
 import {mockLogger} from '../mocks/logger';
-import {mockMQTT, events as mockMQTTEvents} from '../mocks/mqtt';
+import {events as mockMQTTEvents, mockMQTTPublishAsync} from '../mocks/mqtt';
 import {flushPromises} from '../mocks/utils';
 import {devices, groups, events as mockZHEvents, resetGroupMembers, returnDevices} from '../mocks/zigbeeHerdsman';
 
@@ -25,21 +25,21 @@ describe('Extension: Groups', () => {
     let controller: Controller;
 
     beforeAll(async () => {
-        jest.useFakeTimers();
-        controller = new Controller(jest.fn(), jest.fn());
+        vi.useFakeTimers();
+        controller = new Controller(vi.fn(), vi.fn());
         await controller.start();
         await flushPromises();
     });
 
     afterAll(async () => {
-        jest.useRealTimers();
+        vi.useRealTimers();
     });
 
     beforeEach(() => {
         resetGroupMembers();
         data.writeDefaultConfiguration();
         settings.reRead();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         groups.gledopto_group.command.mockClear();
         zhcToZigbee.__clearStore__();
         // @ts-expect-error private
@@ -52,21 +52,21 @@ describe('Extension: Groups', () => {
         const group = groups.group_1;
         group.members.push(endpoint);
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         const payload = {data: {onOff: 1}, cluster: 'genOnOff', device, endpoint, type: 'attributeReport', linkquality: 10};
         await mockZHEvents.message(payload);
         await flushPromises();
 
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(2);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
     });
 
     it('Should not republish identical optimistic group states', async () => {
         const device1 = devices.bulb_2;
         const device2 = devices.bulb_color_2;
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         await mockZHEvents.message({
             data: {onOff: 1},
             cluster: 'genOnOff',
@@ -84,13 +84,13 @@ describe('Extension: Groups', () => {
             linkquality: 10,
         });
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(6);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_tradfri_remote', stringify({state: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_2', stringify({state: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color_2', stringify({state: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_with_tradfri', stringify({state: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/ha_discovery_group', stringify({state: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/switch_group', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(6);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_tradfri_remote', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_2', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color_2', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_with_tradfri', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/ha_discovery_group', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/switch_group', stringify({state: 'ON'}), {retain: false, qos: 0});
     });
 
     it('Should publish state change of all members when a group changes its state', async () => {
@@ -99,12 +99,12 @@ describe('Extension: Groups', () => {
         const group = groups.group_1;
         group.members.push(endpoint);
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'ON'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(2);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
     });
 
     it('Should not publish state change when group changes state and device is disabled', async () => {
@@ -114,11 +114,11 @@ describe('Extension: Groups', () => {
         group.members.push(endpoint);
         settings.set(['devices', device.ieeeAddr, 'disabled'], true);
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'ON'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(1);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
     });
 
     it('Should publish state change for group when members state change', async () => {
@@ -128,37 +128,37 @@ describe('Extension: Groups', () => {
         const group = groups.group_1;
         group.members.push(endpoint);
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         await mockMQTTEvents.message('zigbee2mqtt/bulb_color/set', stringify({state: 'ON'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(2);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'OFF'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(2);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'OFF'}), {retain: false, qos: 0});
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         await mockMQTTEvents.message('zigbee2mqtt/bulb_color/set', stringify({state: 'ON'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(2);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
     });
 
     it('Should publish state of device with endpoint name', async () => {
         const group = groups.gledopto_group;
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         await mockMQTTEvents.message('zigbee2mqtt/gledopto_group/set', stringify({state: 'ON'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(2);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/GLEDOPTO_2ID', stringify({state_cct: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/gledopto_group', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/GLEDOPTO_2ID', stringify({state_cct: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/gledopto_group', stringify({state: 'ON'}), {retain: false, qos: 0});
         expect(group.command).toHaveBeenCalledTimes(1);
         expect(group.command).toHaveBeenCalledWith('genOnOff', 'on', {}, {});
     });
@@ -166,12 +166,12 @@ describe('Extension: Groups', () => {
     it('Should publish state of group when specific state of specific endpoint is changed', async () => {
         const group = groups.gledopto_group;
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         await mockMQTTEvents.message('zigbee2mqtt/GLEDOPTO_2ID/set', stringify({state_cct: 'ON'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(2);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/GLEDOPTO_2ID', stringify({state_cct: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/gledopto_group', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/GLEDOPTO_2ID', stringify({state_cct: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/gledopto_group', stringify({state: 'ON'}), {retain: false, qos: 0});
         expect(group.command).toHaveBeenCalledTimes(0);
     });
 
@@ -182,15 +182,15 @@ describe('Extension: Groups', () => {
         group.members.push(endpoint);
         settings.set(['groups'], {1: {friendly_name: 'group_1', retain: false, filtered_attributes: ['brightness']}});
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'ON', brightness: 100}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(2);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON', brightness: 100}), {
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON', brightness: 100}), {
             retain: false,
             qos: 0,
         });
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
     });
 
     it('Shouldnt publish group state change when a group is not optimistic', async () => {
@@ -200,13 +200,13 @@ describe('Extension: Groups', () => {
         group.members.push(endpoint);
         settings.set(['groups'], {1: {friendly_name: 'group_1', optimistic: false, retain: false}});
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         const payload = {data: {onOff: 1}, cluster: 'genOnOff', device, endpoint, type: 'attributeReport', linkquality: 10};
         await mockZHEvents.message(payload);
         await flushPromises();
 
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(1);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON'}), {retain: false, qos: 0});
     });
 
     it('Should publish state change of another group with shared device when a group changes its state', async () => {
@@ -215,13 +215,13 @@ describe('Extension: Groups', () => {
         groups.group_1.members.push(endpoint);
         groups.group_2.members.push(endpoint);
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'ON'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(3);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_2', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(3);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'ON'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_2', stringify({state: 'ON'}), {retain: false, qos: 0});
     });
 
     it('Should not publish state change off if any lights within are still on when changed via device', async () => {
@@ -235,12 +235,12 @@ describe('Extension: Groups', () => {
 
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'ON'}));
         await flushPromises();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
 
         await mockMQTTEvents.message('zigbee2mqtt/bulb_color/set', stringify({state: 'OFF'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(1);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
     });
 
     it('Should publish state change off if any lights within are still on when changed via device when off_state: last_member_state is used', async () => {
@@ -257,13 +257,13 @@ describe('Extension: Groups', () => {
 
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'ON'}));
         await flushPromises();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
 
         await mockMQTTEvents.message('zigbee2mqtt/bulb_color/set', stringify({state: 'OFF'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(2);
-        expect(mockMQTT.publishAsync).toHaveBeenNthCalledWith(1, 'zigbee2mqtt/group_1', stringify({state: 'OFF'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenNthCalledWith(2, 'zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenNthCalledWith(1, 'zigbee2mqtt/group_1', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenNthCalledWith(2, 'zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
     });
 
     it('Should not publish state change off if any lights within with non default-ep are still on when changed via device', async () => {
@@ -277,12 +277,12 @@ describe('Extension: Groups', () => {
 
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'ON'}));
         await flushPromises();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
 
         await mockMQTTEvents.message('zigbee2mqtt/bulb_color/set', stringify({state: 'OFF'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(1);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
     });
 
     it('Should not publish state change off if any lights within are still on when changed via device with non default-ep', async () => {
@@ -299,12 +299,12 @@ describe('Extension: Groups', () => {
 
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'ON'}));
         await flushPromises();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
 
         await mockMQTTEvents.message('zigbee2mqtt/wall_switch_double/set', stringify({state_left: 'OFF'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(1);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/wall_switch_double', stringify({state_left: 'OFF', state_right: 'ON'}), {
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/wall_switch_double', stringify({state_left: 'OFF', state_right: 'ON'}), {
             retain: false,
             qos: 0,
         });
@@ -324,15 +324,15 @@ describe('Extension: Groups', () => {
 
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'ON'}));
         await flushPromises();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
 
         await mockMQTTEvents.message('zigbee2mqtt/bulb_color/set', stringify({state: 'OFF'}));
         await mockMQTTEvents.message('zigbee2mqtt/wall_switch_double/set', stringify({state_left: 'OFF'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(3);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/wall_switch_double', stringify({state_left: 'OFF'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(3);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/wall_switch_double', stringify({state_left: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'OFF'}), {retain: false, qos: 0});
     });
 
     it('Should not publish state change off if any lights within are still on when changed via shared group', async () => {
@@ -346,13 +346,13 @@ describe('Extension: Groups', () => {
 
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'ON'}));
         await flushPromises();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
 
         await mockMQTTEvents.message('zigbee2mqtt/group_2/set', stringify({state: 'OFF'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(2);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_2', stringify({state: 'OFF'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_2', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
     });
 
     it('Should publish state change off if all lights within turn off', async () => {
@@ -369,15 +369,15 @@ describe('Extension: Groups', () => {
 
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'ON'}));
         await flushPromises();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
 
         await mockMQTTEvents.message('zigbee2mqtt/bulb_color/set', stringify({state: 'OFF'}));
         await mockMQTTEvents.message('zigbee2mqtt/bulb/set', stringify({state: 'OFF'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(3);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb', stringify({state: 'OFF'}), {retain: true, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(3);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb', stringify({state: 'OFF'}), {retain: true, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'OFF'}), {retain: false, qos: 0});
     });
 
     it('Should only update group state with changed properties', async () => {
@@ -391,26 +391,26 @@ describe('Extension: Groups', () => {
         settings.set(['groups'], {
             1: {friendly_name: 'group_1', retain: false},
         });
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
 
         await mockMQTTEvents.message('zigbee2mqtt/bulb_color/set', stringify({state: 'OFF', color_temp: 200}));
         await mockMQTTEvents.message('zigbee2mqtt/bulb/set', stringify({state: 'ON', color_temp: 250}));
         await flushPromises();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
 
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({color_temp: 300}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(3);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(3);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bulb_color',
             stringify({color_mode: 'color_temp', color_temp: 300, state: 'OFF'}),
             {retain: false, qos: 0},
         );
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb', stringify({color_mode: 'color_temp', color_temp: 300, state: 'ON'}), {
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb', stringify({color_mode: 'color_temp', color_temp: 300, state: 'ON'}), {
             retain: true,
             qos: 0,
         });
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/group_1',
             stringify({color_mode: 'color_temp', color_temp: 300, state: 'ON'}),
             {retain: false, qos: 0},
@@ -431,16 +431,16 @@ describe('Extension: Groups', () => {
 
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({state: 'ON'}));
         await flushPromises();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         // @ts-expect-error private
         controller.state.state = {};
 
         await mockMQTTEvents.message('zigbee2mqtt/bulb_color/set', stringify({state: 'OFF'}));
         await flushPromises();
 
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(2);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({state: 'OFF'}), {retain: false, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({state: 'OFF'}), {retain: false, qos: 0});
     });
 
     it('Add to group via MQTT', async () => {
@@ -448,15 +448,15 @@ describe('Extension: Groups', () => {
         const endpoint = device.getEndpoint(1);
         const group = groups.group_1;
         expect(group.members.length).toBe(0);
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
             'zigbee2mqtt/bridge/request/group/members/add',
             stringify({transaction: '123', group: 'group_1', device: 'bulb_color'}),
         );
         await flushPromises();
         expect(group.members).toStrictEqual([endpoint]);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/add',
             stringify({data: {device: 'bulb_color', endpoint: 'default', group: 'group_1'}, transaction: '123', status: 'ok'}),
             {retain: false, qos: 0},
@@ -472,12 +472,12 @@ describe('Extension: Groups', () => {
             throw new Error('timeout');
         });
         await flushPromises();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message('zigbee2mqtt/bridge/request/group/members/add', stringify({group: 'group_1', device: 'bulb_color'}));
         await flushPromises();
         expect(group.members).toStrictEqual([]);
-        expect(mockMQTT.publishAsync).not.toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).not.toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/add',
             stringify({data: {}, status: 'error', error: 'Failed to add from group (timeout)'}),
             {retain: false, qos: 0},
@@ -490,12 +490,12 @@ describe('Extension: Groups', () => {
         const group = groups['group/with/slashes'];
         settings.set(['groups'], {99: {friendly_name: 'group/with/slashes', retain: false}});
         expect(group.members.length).toBe(0);
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message('zigbee2mqtt/bridge/request/group/members/add', stringify({group: 'group/with/slashes', device: 'bulb_color'}));
         await flushPromises();
         expect(group.members).toStrictEqual([endpoint]);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/add',
             stringify({data: {device: 'bulb_color', endpoint: 'default', group: 'group/with/slashes'}, status: 'ok'}),
             {retain: false, qos: 0},
@@ -507,15 +507,15 @@ describe('Extension: Groups', () => {
         const endpoint = device.getEndpoint(3)!;
         const group = groups.group_1;
         expect(group.members.length).toBe(0);
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
             'zigbee2mqtt/bridge/request/group/members/add',
             stringify({group: 'group_1', device: 'wall_switch_double', endpoint: 'right'}),
         );
         await flushPromises();
         expect(group.members).toStrictEqual([endpoint]);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/add',
             stringify({data: {device: 'wall_switch_double', endpoint: 'right', group: 'group_1'}, status: 'ok'}),
             {retain: false, qos: 0},
@@ -527,7 +527,7 @@ describe('Extension: Groups', () => {
         const endpoint = device.getEndpoint(3)!;
         const group = groups.group_1;
         expect(group.members.length).toBe(0);
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
             'zigbee2mqtt/bridge/request/group/members/add',
             stringify({group: 'group_1', device: 'wall_switch_double', endpoint: 'right'}),
@@ -539,8 +539,8 @@ describe('Extension: Groups', () => {
         );
         await flushPromises();
         expect(group.members).toStrictEqual([endpoint]);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/add',
             stringify({data: {device: 'wall_switch_double', endpoint: 'right', group: 'group_1'}, status: 'ok'}),
             {retain: false, qos: 0},
@@ -552,12 +552,12 @@ describe('Extension: Groups', () => {
         const endpoint = device.getEndpoint(1)!;
         const group = groups.group_1;
         group.members.push(endpoint);
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message('zigbee2mqtt/bridge/request/group/members/remove', stringify({group: 'group_1', device: 'bulb_color'}));
         await flushPromises();
         expect(group.members).toStrictEqual([]);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/remove',
             stringify({data: {device: 'bulb_color', endpoint: 'default', group: 'group_1'}, status: 'ok'}),
             {retain: false, qos: 0},
@@ -569,15 +569,15 @@ describe('Extension: Groups', () => {
         const endpoint = device.getEndpoint(1)!;
         const group = groups.group_1;
         group.members.push(endpoint);
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
             'zigbee2mqtt/bridge/request/group/members/remove',
             stringify({group: 'group_1', device: 'bulb_color', skip_disable_reporting: true}),
         );
         await flushPromises();
         expect(group.members).toStrictEqual([]);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/remove',
             stringify({data: {device: 'bulb_color', endpoint: 'default', group: 'group_1'}, status: 'ok'}),
             {retain: false, qos: 0},
@@ -589,15 +589,15 @@ describe('Extension: Groups', () => {
         const endpoint = device.getEndpoint(3)!;
         const group = groups.group_1;
         group.members.push(endpoint);
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
             'zigbee2mqtt/bridge/request/group/members/remove',
             stringify({group: 'group_1', device: '0x0017880104e45542', endpoint: '3'}),
         );
         await flushPromises();
         expect(group.members).toStrictEqual([]);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/remove',
             stringify({data: {device: '0x0017880104e45542', endpoint: '3', group: 'group_1'}, status: 'ok'}),
             {retain: false, qos: 0},
@@ -609,15 +609,15 @@ describe('Extension: Groups', () => {
         const endpoint = device.getEndpoint(3)!;
         const group = groups.group_1;
         group.members.push(endpoint);
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
             'zigbee2mqtt/bridge/request/group/members/remove',
             stringify({group: 'group_1', device: 'wall_switch_double', endpoint: '3'}),
         );
         await flushPromises();
         expect(group.members).toStrictEqual([]);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/remove',
             stringify({data: {device: 'wall_switch_double', endpoint: '3', group: 'group_1'}, status: 'ok'}),
             {retain: false, qos: 0},
@@ -629,15 +629,15 @@ describe('Extension: Groups', () => {
         const endpoint = device.getEndpoint(3)!;
         const group = groups.group_1;
         group.members.push(endpoint);
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
             'zigbee2mqtt/bridge/request/group/members/remove',
             stringify({group: 'group_1', device: '0x0017880104e45542', endpoint: 'right'}),
         );
         await flushPromises();
         expect(group.members).toStrictEqual([]);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/remove',
             stringify({data: {device: '0x0017880104e45542', endpoint: 'right', group: 'group_1'}, status: 'ok'}),
             {retain: false, qos: 0},
@@ -647,12 +647,12 @@ describe('Extension: Groups', () => {
     it('Remove from group all', async () => {
         const group = groups.group_1;
         groups.group_1.members.push(devices.QBKG03LM.endpoints[2]);
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message('zigbee2mqtt/bridge/request/group/members/remove_all', stringify({device: '0x0017880104e45542', endpoint: 'right'}));
         await flushPromises();
         expect(group.members).toStrictEqual([]);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/remove_all',
             stringify({data: {device: '0x0017880104e45542', endpoint: 'right'}, status: 'ok'}),
             {retain: false, qos: 0},
@@ -661,11 +661,11 @@ describe('Extension: Groups', () => {
 
     it('Error when adding to non-existing group', async () => {
         mockLogger.error.mockClear();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message('zigbee2mqtt/bridge/request/group/members/remove', stringify({group: 'group_1_not_existing', device: 'bulb_color'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).not.toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).not.toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/remove',
             stringify({data: {}, status: 'error', error: "Group 'group_1_not_existing' does not exist"}),
             {retain: false, qos: 0},
@@ -674,11 +674,11 @@ describe('Extension: Groups', () => {
 
     it('Error when adding a non-existing device', async () => {
         mockLogger.error.mockClear();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message('zigbee2mqtt/bridge/request/group/members/add', stringify({group: 'group_1', device: 'bulb_color_not_existing'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).not.toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).not.toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/add',
             stringify({data: {}, status: 'error', error: "Device 'bulb_color_not_existing' does not exist"}),
             {retain: false, qos: 0},
@@ -687,14 +687,14 @@ describe('Extension: Groups', () => {
 
     it('Error when adding a non-existing endpoint', async () => {
         mockLogger.error.mockClear();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message(
             'zigbee2mqtt/bridge/request/group/members/add',
             stringify({group: 'group_1', device: 'bulb_color', endpoint: 'not_existing_endpoint'}),
         );
         await flushPromises();
-        expect(mockMQTT.publishAsync).not.toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).not.toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/add',
             stringify({data: {}, status: 'error', error: "Device 'bulb_color' does not have endpoint 'not_existing_endpoint'"}),
             {retain: false, qos: 0},
@@ -703,11 +703,11 @@ describe('Extension: Groups', () => {
 
     it('Error when invalid payload', async () => {
         mockLogger.error.mockClear();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message('zigbee2mqtt/bridge/request/group/members/add', stringify({group: 'group_1', devicez: 'bulb_color'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).not.toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).not.toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/add',
             stringify({data: {}, status: 'error', error: 'Invalid payload'}),
             {retain: false, qos: 0},
@@ -716,11 +716,11 @@ describe('Extension: Groups', () => {
 
     it('Error when add/remove with invalid payload', async () => {
         mockLogger.error.mockClear();
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message('zigbee2mqtt/bridge/request/group/members/add', stringify({groupz: 'group_1', device: 'bulb_color'}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).not.toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).not.toHaveBeenCalledWith('zigbee2mqtt/bridge/groups', expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bridge/response/group/members/add',
             stringify({data: {}, status: 'error', error: 'Invalid payload'}),
             {retain: false, qos: 0},
@@ -734,38 +734,38 @@ describe('Extension: Groups', () => {
         group.members.push(bulbColor.getEndpoint(1)!);
         group.members.push(bulbColorTemp.getEndpoint(1)!);
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({color_temp: 50}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(3);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({color_mode: 'color_temp', color_temp: 50}), {
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(3);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb_color', stringify({color_mode: 'color_temp', color_temp: 50}), {
             retain: false,
             qos: 0,
         });
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({color_mode: 'color_temp', color_temp: 50}), {
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/group_1', stringify({color_mode: 'color_temp', color_temp: 50}), {
             retain: false,
             qos: 0,
         });
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb', stringify({color_mode: 'color_temp', color_temp: 50}), {
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb', stringify({color_mode: 'color_temp', color_temp: 50}), {
             retain: true,
             qos: 0,
         });
 
-        mockMQTT.publishAsync.mockClear();
+        mockMQTTPublishAsync.mockClear();
         await mockMQTTEvents.message('zigbee2mqtt/group_1/set', stringify({color: {x: 0.5, y: 0.3}}));
         await flushPromises();
-        expect(mockMQTT.publishAsync).toHaveBeenCalledTimes(3);
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(3);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/bulb_color',
             stringify({color: {x: 0.5, y: 0.3}, color_mode: 'xy', color_temp: 548}),
             {retain: false, qos: 0},
         );
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith(
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             'zigbee2mqtt/group_1',
             stringify({color: {x: 0.5, y: 0.3}, color_mode: 'xy', color_temp: 548}),
             {retain: false, qos: 0},
         );
-        expect(mockMQTT.publishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb', stringify({color_mode: 'color_temp', color_temp: 548}), {
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith('zigbee2mqtt/bulb', stringify({color_mode: 'color_temp', color_temp: 548}), {
             retain: true,
             qos: 0,
         });