1.25.0

Co-authored-by: Koenkk <Koenkk@users.noreply.github.com>

.github/ISSUE_TEMPLATE/problem_report.yaml

@@ -37,7 +37,7 @@ body:
     id: z2m_version
     attributes:
       label: Zigbee2MQTT version
-      description: Can be found in the frontend -> settings -> about -> Zigbee2MQTT version
+      description: Can be found in the frontend -> settings -> about -> Zigbee2MQTT version. Are you running Zigbee2MQTT 1.18.1? Then read [this](https://github.com/Koenkk/zigbee2mqtt/releases/tag/1.19.0).
       placeholder: '1.22.1'
     validations:
       required: true

.github/workflows/ci.yml

@@ -7,10 +7,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
-    - uses: actions/setup-node@v2-beta
+    - uses: actions/setup-node@v2
       with:
-        node-version: 14
-        registry-url: https://registry.npmjs.org/
+        node-version: 16
     - name: Get NodeJS Version
       id: nodeversion
       run: |

.github/workflows/update_deps.yml

@@ -14,7 +14,7 @@ jobs:
         ssh-key: ${{ secrets.SSH_PRIVATE_KEY }}
     - uses: actions/setup-node@v2-beta
       with:
-        node-version: 14
+        node-version: 16
     - run: rm -rf npm-shrinkwrap.json
     - run: npx npm-check-updates -u
     - run: npm install && npm shrinkwrap --dev

.github/workflows/update_frontend.yml

@@ -13,7 +13,7 @@ jobs:
         ssh-key: ${{ secrets.SSH_PRIVATE_KEY }}
     - uses: actions/setup-node@v2-beta
       with:
-        node-version: 14
+        node-version: 16
     - run: npm install zigbee2mqtt-frontend@${{ github.event.client_payload.version }} --save-exact
     - uses: peter-evans/create-pull-request@v3
       id: cpr

.github/workflows/update_zh.yml

@@ -13,7 +13,7 @@ jobs:
         ssh-key: ${{ secrets.SSH_PRIVATE_KEY }}
     - uses: actions/setup-node@v2-beta
       with:
-        node-version: 14
+        node-version: 16
     - run: npm install zigbee-herdsman@${{ github.event.client_payload.version }} --save-exact
     - uses: peter-evans/create-pull-request@v3
       id: cpr

.github/workflows/update_zhc.yml

@@ -13,7 +13,7 @@ jobs:
         ssh-key: ${{ secrets.SSH_PRIVATE_KEY }}
     - uses: actions/setup-node@v2-beta
       with:
-        node-version: 14
+        node-version: 16
     - run: npm install zigbee-herdsman-converters@${{ github.event.client_payload.version }} --save-exact
     - uses: peter-evans/create-pull-request@v3
       id: cpr

docker/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:14-alpine3.12 as base
+FROM node:16-alpine3.15 as base
 
 WORKDIR /app
 RUN apk add --no-cache tzdata eudev tini

lib/extension/availability.ts

@@ -5,6 +5,12 @@ import * as settings from '../util/settings';
 import debounce from 'debounce';
 import bind from 'bind-decorator';
 
+const retrieveOnReconnect = [
+    {keys: ['state']},
+    {keys: ['brightness'], condition: (state: KeyValue): boolean => state.state === 'ON'},
+    {keys: ['color', 'color_temp'], condition: (state: KeyValue): boolean => state.state === 'ON'},
+];
+
 export default class Availability extends Extension {
     private timers: {[s: string]: NodeJS.Timeout} = {};
     private availabilityCache: {[s: string]: boolean} = {};
@@ -28,9 +34,14 @@ export default class Availability extends Extension {
             device.zh.powerSource === 'Mains (single phase)';
     }
 
-    private isAvailable(device: Device): boolean {
-        const ago = Date.now() - device.zh.lastSeen;
-        return ago < this.getTimeout(device);
+    private isAvailable(entity: Device | Group): boolean {
+        if (entity.isDevice()) {
+            const ago = Date.now() - entity.zh.lastSeen;
+            return ago < this.getTimeout(entity);
+        } else {
+            return entity.membersDevices().length === 0 ||
+                entity.membersDevices().map((d) => this.availabilityCache[d.ieeeAddr]).includes(true);
+        }
     }
 
     private resetTimer(device: Device): void {
@@ -93,7 +104,7 @@ export default class Availability extends Extension {
 
     override async start(): Promise<void> {
         this.eventBus.onEntityRenamed(this, (data) => {
-            if (data.entity.isDevice() && utils.isAvailabilityEnabledForDevice(data.entity, settings.get())) {
+            if (utils.isAvailabilityEnabledForEntity(data.entity, settings.get())) {
                 this.mqtt.publish(`${data.from}/availability`, null, {retain: true, qos: 0});
                 this.publishAvailability(data.entity, false, true);
             }
@@ -103,57 +114,67 @@ export default class Availability extends Extension {
         this.eventBus.onDeviceLeave(this, (data) => clearTimeout(this.timers[data.ieeeAddr]));
         this.eventBus.onDeviceAnnounce(this, (data) => this.retrieveState(data.device));
         this.eventBus.onLastSeenChanged(this, this.onLastSeenChanged);
-        this.eventBus.onPublishAvailability(this, this.publishAvailabilityForAllDevices);
-        this.publishAvailabilityForAllDevices();
+        this.eventBus.onPublishAvailability(this, this.publishAvailabilityForAllEntities);
+        this.eventBus.onGroupMembersChanged(this, (data) => this.publishAvailability(data.group, false));
+        this.publishAvailabilityForAllEntities();
     }
 
-    @bind private publishAvailabilityForAllDevices(): void {
-        for (const device of this.zigbee.devices(false)) {
-            if (utils.isAvailabilityEnabledForDevice(device, settings.get())) {
+    @bind private publishAvailabilityForAllEntities(): void {
+        for (const entity of [...this.zigbee.devices(false), ...this.zigbee.groups()]) {
+            if (utils.isAvailabilityEnabledForEntity(entity, settings.get())) {
                 // Publish initial availablility
-                this.publishAvailability(device, true);
+                this.publishAvailability(entity, true, false, true);
 
-                this.resetTimer(device);
+                if (entity.isDevice()) {
+                    this.resetTimer(entity);
 
-                // If an active device is initially unavailable, ping it.
-                if (this.isActiveDevice(device) && !this.isAvailable(device)) {
-                    this.addToPingQueue(device);
+                    // If an active device is initially unavailable, ping it.
+                    if (this.isActiveDevice(entity) && !this.isAvailable(entity)) {
+                        this.addToPingQueue(entity);
+                    }
                 }
             }
         }
     }
 
-    private publishAvailability(device: Device, logLastSeen: boolean, forcePublish=false): void {
-        if (logLastSeen) {
-            const ago = Date.now() - device.zh.lastSeen;
-            if (this.isActiveDevice(device)) {
-                logger.debug(`Active device '${device.name}' was last seen ` +
+    private publishAvailability(entity: Device | Group, logLastSeen: boolean,
+        forcePublish=false, skipGroups=false): void {
+        if (logLastSeen && entity.isDevice()) {
+            const ago = Date.now() - entity.zh.lastSeen;
+            if (this.isActiveDevice(entity)) {
+                logger.debug(`Active device '${entity.name}' was last seen ` +
                     `'${(ago / utils.minutes(1)).toFixed(2)}' minutes ago.`);
             } else {
                 logger.debug(
-                    `Passive device '${device.name}' was last seen '${(ago / utils.hours(1)).toFixed(2)}' hours ago.`);
+                    `Passive device '${entity.name}' was last seen '${(ago / utils.hours(1)).toFixed(2)}' hours ago.`);
             }
         }
 
-        const available = this.isAvailable(device);
-        if (!forcePublish && this.availabilityCache[device.ieeeAddr] == available) {
+        const available = this.isAvailable(entity);
+        if (!forcePublish && this.availabilityCache[entity.ID] == available) {
             return;
         }
 
-        if (device.ieeeAddr in this.availabilityCache && available &&
-            this.availabilityCache[device.ieeeAddr] === false) {
-            logger.debug(`Device '${device.name}' reconnected`);
-            this.retrieveState(device);
+        if (entity.isDevice() && entity.ieeeAddr in this.availabilityCache && available &&
+            this.availabilityCache[entity.ieeeAddr] === false) {
+            logger.debug(`Device '${entity.name}' reconnected`);
+            this.retrieveState(entity);
         }
 
-        const topic = `${device.name}/availability`;
+        const topic = `${entity.name}/availability`;
         const payload = utils.availabilityPayload(available ? 'online' : 'offline', settings.get());
-        this.availabilityCache[device.ieeeAddr] = available;
+        this.availabilityCache[entity.ID] = available;
         this.mqtt.publish(topic, payload, {retain: true, qos: 0});
+
+        if (!skipGroups && entity.isDevice()) {
+            this.zigbee.groups().filter((g) => g.hasMember(entity))
+                .filter((g) => utils.isAvailabilityEnabledForEntity(g, settings.get()))
+                .forEach((g) => this.publishAvailability(g, false, forcePublish));
+        }
     }
 
     @bind private onLastSeenChanged(data: eventdata.LastSeenChanged): void {
-        if (utils.isAvailabilityEnabledForDevice(data.device, settings.get())) {
+        if (utils.isAvailabilityEnabledForEntity(data.device, settings.get())) {
             // Remove from ping queue, not necessary anymore since we know the device is online.
             this.removeFromPingQueue(data.device);
             this.resetTimer(data.device);
@@ -172,17 +193,18 @@ export default class Availability extends Extension {
          * device can send multiple times after each other.
          */
         if (device.definition && !device.zh.interviewing && !this.retrieveStateDebouncers[device.ieeeAddr]) {
-            this.retrieveStateDebouncers[device.ieeeAddr] = debounce(() => {
+            this.retrieveStateDebouncers[device.ieeeAddr] = debounce(async () => {
                 logger.debug(`Retrieving state of '${device.name}' after reconnect`);
                 // Color and color temperature converters do both, only needs to be called once.
-                const keySet = [['state'], ['brightness'], ['color', 'color_temp']];
-                for (const keys of keySet) {
-                    const converter = device.definition.toZigbee.find((c) => c.key.find((k) => keys.includes(k)));
-                    converter?.convertGet?.(device.endpoint(), keys[0],
+                for (const item of retrieveOnReconnect) {
+                    if (item.condition && this.state.get(device) && !item.condition(this.state.get(device))) continue;
+                    const converter = device.definition.toZigbee.find((c) => c.key.find((k) => item.keys.includes(k)));
+                    await converter?.convertGet?.(device.endpoint(), item.keys[0],
                         {message: this.state.get(device) || {}, mapped: device.definition})
                         .catch((e) => {
                             logger.error(`Failed to read state of '${device.name}' after reconnect (${e.message})`);
                         });
+                    await utils.sleep(500);
                 }
             }, utils.seconds(2));
         }

lib/extension/configure.ts

@@ -85,7 +85,7 @@ export default class Configure extends Extension {
     private async configure(device: Device, event: 'started' | 'zigbee_event' | 'reporting_disabled' | 'mqtt_message',
         force=false, thowError=false): Promise<void> {
         if (!force) {
-            if (!device.definition?.configure || device.zh.interviewing) {
+            if (!device.definition?.configure || !device.zh.interviewCompleted) {
                 return;
             }
 

lib/extension/homeassistant.ts

@@ -380,6 +380,8 @@ export default class HomeAssistant extends Extension {
         } else if (firstExpose.type === 'cover') {
             const position = exposes.find((expose) => expose.features.find((e) => e.name === 'position'));
             const tilt = exposes.find((expose) => expose.features.find((e) => e.name === 'tilt'));
+            const motorState = definitionExposes?.find((e) => e.type === 'enum' && e.name === 'motor_state' &&
+                e.access === ACCESS_STATE);
 
             const discoveryEntry: DiscoveryEntry = {
                 type: 'cover',
@@ -398,6 +400,43 @@ export default class HomeAssistant extends Extension {
                 discoveryEntry.discovery_payload.command_topic = true;
                 discoveryEntry.discovery_payload.state_topic = !position;
                 discoveryEntry.discovery_payload.command_topic_prefix = endpoint;
+
+                // For curtains that have `motor_state` lookup a possible state names and make this
+                // available for discovery. If the curtains only support the `running` value,
+                // then we use it anyway. The movement direction is calculated (assumed) in this case.
+                if (motorState) {
+                    const openingLookup = ['opening', 'open', 'forward', 'up', 'rising'];
+                    const closingLookup = ['closing', 'close', 'backward', 'back', 'reverse', 'down', 'declining'];
+                    const stoppedLookup = ['stopped', 'stop', 'pause', 'paused'];
+
+                    const openingState = motorState.values.find((s) => openingLookup.includes(s.toLowerCase()));
+                    const closingState = motorState.values.find((s) => closingLookup.includes(s.toLowerCase()));
+                    const stoppedState = motorState.values.find((s) => stoppedLookup.includes(s.toLowerCase()));
+
+                    if (openingState) {
+                        discoveryEntry.discovery_payload.state_opening = openingState;
+                    }
+                    if (closingState) {
+                        discoveryEntry.discovery_payload.state_closing = closingState;
+                    }
+                    if (stoppedState) {
+                        discoveryEntry.discovery_payload.state_stopped = stoppedState;
+                    }
+
+                    if (openingState || closingState || stoppedState) {
+                        discoveryEntry.discovery_payload.state_topic = true;
+                        discoveryEntry.discovery_payload.value_template = `{{ value_json.motor_state }}`;
+                    }
+                } else {
+                    const running = definitionExposes?.find((e) => e.type === 'binary' && e.name === 'running');
+
+                    if (running) {
+                        discoveryEntry.discovery_payload.state_topic = true;
+                        discoveryEntry.discovery_payload.value_template = `{% if not value_json.running %} ` +
+                            `stopped {% else %} {% if value_json.position > 0 %} closing {% else %} ` +
+                            `opening {% endif %} {% endif %}`;
+                    }
+                }
             }
 
             if (!position && !tilt) {
@@ -499,6 +538,7 @@ export default class HomeAssistant extends Extension {
                 color_sync: {entity_category: 'config', icon: 'mdi:sync-circle'},
                 consumer_connected: {entity_category: 'diagnostic', device_class: 'connectivity'},
                 contact: {device_class: 'door'},
+                garage_door_contact: {device_class: 'garage'},
                 eco_mode: {entity_category: 'config', icon: 'mdi:leaf'},
                 expose_pin: {entity_category: 'config', icon: 'mdi:pin'},
                 gas: {device_class: 'gas'},
@@ -1093,10 +1133,8 @@ export default class HomeAssistant extends Extension {
             // Availability payload
             payload.availability = [{topic: `${settings.get().mqtt.base_topic}/bridge/state`}];
 
-            const availabilityEnabled =
-                entity.isDevice() && utils.isAvailabilityEnabledForDevice(entity, settings.get());
             /* istanbul ignore next */
-            if (availabilityEnabled) {
+            if (utils.isAvailabilityEnabledForEntity(entity, settings.get())) {
                 payload.availability_mode = 'all';
                 payload.availability.push({topic: `${baseTopic}/availability`});
             }

lib/model/group.ts

@@ -4,13 +4,23 @@ import zigbeeHerdsmanConverters from 'zigbee-herdsman-converters';
 
 export default class Group {
     public zh: zh.Group;
+    private resolveDevice: (ieeeAddr: string) => Device;
 
     get ID(): number {return this.zh.groupID;}
     get options(): GroupOptions {return {...settings.getGroup(this.ID)};}
     get name(): string {return this.options?.friendly_name || this.ID.toString();}
 
-    constructor(group: zh.Group) {
+    constructor(group: zh.Group, resolveDevice: (ieeeAddr: string) => Device) {
         this.zh = group;
+        this.resolveDevice = resolveDevice;
+    }
+
+    hasMember(device: Device): boolean {
+        return !!device.zh.endpoints.find((e) => this.zh.members.includes(e));
+    }
+
+    membersDevices(): Device[] {
+        return this.zh.members.map((e) => this.resolveDevice(e.getDevice().ieeeAddr)).filter((d) => d);
     }
 
     membersDefinitions(): zhc.Definition[] {

lib/util/logger.ts

@@ -62,7 +62,12 @@ const transportsToUse: winston.transport[] = [
             winston.format.printf(/* istanbul ignore next */(info) => {
                 const {timestamp, level, message} = info;
                 const l = winstonToZ2mLevel(level as WinstonLogLevel);
-                const prefix = colorizer.colorize(l, `Zigbee2MQTT:${levelWithCompensatedLength[l]}`);
+
+                const plainPrefix = `Zigbee2MQTT:${levelWithCompensatedLength[l]}`;
+                let prefix = plainPrefix;
+                if (process.stdout.isTTY) {
+                    prefix = colorizer.colorize(l, plainPrefix);
+                }
                 return `${prefix} ${timestamp.split('.')[0]}: ${message}`;
             }),
         ),

lib/util/utils.ts

@@ -38,7 +38,7 @@ const endpointNames = [
     'button_11', 'button_12', 'button_13', 'button_14', 'button_15',
     'button_16', 'button_17', 'button_18', 'button_19', 'button_20',
     'button_light', 'button_fan_high', 'button_fan_med', 'button_fan_low',
-    'heat', 'cool', 'water', 'meter', 'wifi',
+    'heat', 'cool', 'water', 'meter', 'wifi', 'no_occupancy_since',
 ];
 
 function capitalize(s: string): string {
@@ -245,9 +245,13 @@ function sanitizeImageParameter(parameter: string): string {
     return sanitized;
 }
 
-function isAvailabilityEnabledForDevice(device: Device, settings: Settings): boolean {
-    if (device.options.hasOwnProperty('availability')) {
-        return !!device.options.availability;
+function isAvailabilityEnabledForEntity(entity: Device | Group, settings: Settings): boolean {
+    if (entity.isGroup()) {
+        return !entity.membersDevices().map((d) => isAvailabilityEnabledForEntity(d, settings)).includes(false);
+    }
+
+    if (entity.options.hasOwnProperty('availability')) {
+        return !!entity.options.availability;
     }
 
     // availability_timeout = deprecated
@@ -256,11 +260,11 @@ function isAvailabilityEnabledForDevice(device: Device, settings: Settings): boo
 
     const passlist = settings.advanced.availability_passlist.concat(settings.advanced.availability_whitelist);
     if (passlist.length > 0) {
-        return passlist.includes(device.name) || passlist.includes(device.ieeeAddr);
+        return passlist.includes(entity.name) || passlist.includes(entity.ieeeAddr);
     }
 
     const blocklist = settings.advanced.availability_blacklist.concat(settings.advanced.availability_blocklist);
-    return !blocklist.includes(device.name) && !blocklist.includes(device.ieeeAddr);
+    return !blocklist.includes(entity.name) && !blocklist.includes(entity.ieeeAddr);
 }
 
 const entityIDRegex = new RegExp(`^(.+?)(?:/(${endpointNames.join('|')}|\\d+))?$`);
@@ -306,5 +310,5 @@ export default {
     equalsPartial, getObjectProperty, getResponse, parseJSON, loadModuleFromText, loadModuleFromFile,
     getExternalConvertersDefinitions, removeNullPropertiesFromObject, toNetworkAddressHex, toSnakeCase,
     parseEntityID, isEndpoint, isZHGroup, hours, minutes, seconds, validateFriendlyName, sleep,
-    sanitizeImageParameter, isAvailabilityEnabledForDevice, publishLastSeen, availabilityPayload,
+    sanitizeImageParameter, isAvailabilityEnabledForEntity, publishLastSeen, availabilityPayload,
 };

lib/zigbee.ts

@@ -219,7 +219,7 @@ export default class Zigbee {
         }
     }
 
-    private resolveDevice(ieeeAddr: string): Device {
+    @bind private resolveDevice(ieeeAddr: string): Device {
         if (!this.deviceLookup[ieeeAddr]) {
             const device = this.herdsman.getDeviceByIeeeAddr(ieeeAddr);
             device && (this.deviceLookup[ieeeAddr] = new Device(device));
@@ -235,7 +235,7 @@ export default class Zigbee {
     private resolveGroup(groupID: number): Group {
         const group = this.herdsman.getGroupByID(Number(groupID));
         if (group && !this.groupLookup[groupID]) {
-            this.groupLookup[groupID] = new Group(group);
+            this.groupLookup[groupID] = new Group(group, this.resolveDevice);
         }
 
         return this.groupLookup[groupID];

package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee2mqtt",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "description": "Zigbee to MQTT bridge using Zigbee-herdsman",
   "main": "index.js",
   "repository": {
@@ -35,21 +35,21 @@
   },
   "homepage": "https://koenkk.github.io/zigbee2mqtt",
   "dependencies": {
-    "ajv": "^8.10.0",
+    "ajv": "^8.11.0",
     "bind-decorator": "^1.0.11",
     "connect-gzip-static": "^2.1.1",
     "core-js": "^3.21.1",
     "debounce": "^1.2.1",
     "deep-object-diff": "^1.1.7",
     "fast-deep-equal": "^3.1.3",
-    "finalhandler": "^1.1.2",
+    "finalhandler": "^1.2.0",
     "git-last-commit": "^1.0.1",
     "humanize-duration": "^3.27.1",
     "js-yaml": "^4.1.0",
     "json-stable-stringify-without-jsonify": "^1.0.1",
     "mkdir-recursive": "^0.4.0",
     "moment": "^2.29.1",
-    "mqtt": "4.3.6",
+    "mqtt": "4.3.7",
     "object-assign-deep": "^0.4.0",
     "rimraf": "^3.0.2",
     "semver": "^7.3.5",
@@ -60,12 +60,12 @@
     "winston-transport": "^4.5.0",
     "ws": "^8.5.0",
     "zigbee-herdsman": "0.14.20",
-    "zigbee-herdsman-converters": "14.0.438",
-    "zigbee2mqtt-frontend": "0.6.76"
+    "zigbee-herdsman-converters": "14.0.467",
+    "zigbee2mqtt-frontend": "0.6.80"
   },
   "devDependencies": {
-    "@babel/core": "^7.17.5",
-    "@babel/plugin-proposal-decorators": "^7.17.2",
+    "@babel/core": "^7.17.8",
+    "@babel/plugin-proposal-decorators": "^7.17.8",
     "@babel/preset-env": "^7.16.11",
     "@babel/preset-typescript": "^7.16.7",
     "@types/debounce": "^1.2.1",
@@ -75,16 +75,16 @@
     "@types/js-yaml": "^4.0.5",
     "@types/object-assign-deep": "^0.4.0",
     "@types/rimraf": "^3.0.2",
-    "@types/ws": "^8.5.1",
-    "@typescript-eslint/eslint-plugin": "^5.12.1",
-    "@typescript-eslint/parser": "^5.12.1",
+    "@types/ws": "^8.5.3",
+    "@typescript-eslint/eslint-plugin": "^5.16.0",
+    "@typescript-eslint/parser": "^5.16.0",
     "babel-jest": "^27.5.1",
-    "eslint": "^8.10.0",
+    "eslint": "^8.12.0",
     "eslint-config-google": "^0.14.0",
-    "eslint-plugin-jest": "^26.1.1",
+    "eslint-plugin-jest": "^26.1.3",
     "jest": "^27.5.1",
     "tmp": "^0.2.1",
-    "typescript": "^4.5.5"
+    "typescript": "^4.6.3"
   },
   "jest": {
     "coverageThreshold": {

test/availability.test.js

@@ -241,6 +241,9 @@ describe('Availability', () => {
     it('Should retrieve device state when it reconnects', async () => {
         MQTT.publish.mockClear();
 
+        const device = controller.zigbee.resolveEntity(devices.bulb_color.ieeeAddr);
+        controller.state.set(device, {state: 'OFF'})
+
         const endpoint = devices.bulb_color.getEndpoint(1);
         endpoint.read.mockClear();
 
@@ -253,18 +256,15 @@ describe('Availability', () => {
         expect(endpoint.read).toHaveBeenCalledTimes(0);
         await advancedTime(utils.seconds(2));
 
-        expect(endpoint.read).toHaveBeenCalledTimes(3);
+        expect(endpoint.read).toHaveBeenCalledTimes(1);
         expect(endpoint.read).toHaveBeenCalledWith('genOnOff', ['onOff']);
-        expect(endpoint.read).toHaveBeenCalledWith('genLevelCtrl', ['currentLevel']);
-        expect(endpoint.read).toHaveBeenCalledWith('lightingColorCtrl',
-            ['colorMode', 'currentX', 'currentY', 'enhancedCurrentHue', 'currentSaturation', 'colorTemperature']);
 
         endpoint.read.mockClear();
         await zigbeeHerdsman.events.deviceAnnounce({device: devices.bulb_color});
         await flushPromises();
         endpoint.read.mockImplementationOnce(() => {throw new Error('')});
         await advancedTime(utils.seconds(3));
-        expect(endpoint.read).toHaveBeenCalledTimes(3);
+        expect(endpoint.read).toHaveBeenCalledTimes(1);
     });
 
     it('Should republish availability when device is renamed', async () => {
@@ -318,4 +318,21 @@ describe('Availability', () => {
         await advancedTime(utils.minutes(12));
         expect(devices.bulb_color.ping).toHaveBeenCalledTimes(1);
     });
+
+    it('Should publish availabilty for groups', async () => {
+        settings.set(['devices', devices.bulb_color_2.ieeeAddr, 'availability'], true);
+        await resetExtension();
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/group_tradfri_remote/availability',
+            'online', {retain: true, qos: 0}, expect.any(Function));
+        MQTT.publish.mockClear();
+        await advancedTime(utils.minutes(12));
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/group_tradfri_remote/availability',
+            'offline', {retain: true, qos: 0}, expect.any(Function));
+        MQTT.publish.mockClear();
+        devices.bulb_color_2.lastSeen = Date.now();
+        await zigbeeHerdsman.events.lastSeenChanged({device: devices.bulb_color_2});
+        await flushPromises();
+        expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/group_tradfri_remote/availability',
+            'online', {retain: true, qos: 0}, expect.any(Function));
+    });
 });

test/configure.test.js

@@ -192,19 +192,7 @@ describe('Configure', () => {
         expect(logger.warn).toHaveBeenCalledWith(`Skipping configure of 'ZNLDP12LM', device does not require this.`)
     });
 
-    it('Should not configure when interviewing', async () => {
-        const device = zigbeeHerdsman.devices.remote;
-        delete device.meta.configured;
-        device.interviewing = true;
-        const endpoint = device.getEndpoint(1);
-        mockClear(device);
-        await zigbeeHerdsman.events.lastSeenChanged({device});
-        await flushPromises();
-        expectRemoteNotConfigured();
-        device.interviewing = false;
-    });
-
-    it('Should configure when not interviewCompleted', async () => {
+    it('Should not configure when interview not completed', async () => {
         const device = zigbeeHerdsman.devices.remote;
         delete device.meta.configured;
         device.interviewCompleted = false;
@@ -212,7 +200,7 @@ describe('Configure', () => {
         mockClear(device);
         await zigbeeHerdsman.events.lastSeenChanged({device});
         await flushPromises();
-        expectRemoteConfigured();
+        expectRemoteNotConfigured();
         device.interviewCompleted = true;
     });