mirror of
https://github.com/Koenkk/zigbee2mqtt.git
synced 2026-07-20 02:21:20 +00:00
Yip Rui FungandGitHub
d1e50ce534
* Use QOS1 for rarely sent messages Specifically discovery and availability depending on the set up, it's possible for these messages to be silently discarded by the broker. Sending them as QOS1 means the mqtt library used will resend them until it gets an ACK. Ensuring delivery is particularly important for messages that are rarely sent like discovery or availability as they are only sent when there are changes, and nondelivery or dropped messages for them impede proper functioning in home assistant. * Fix tests for discovery and availability using QOS1
2112 lines
86 KiB
JavaScript
2112 lines
86 KiB
JavaScript
const data = require('./stub/data');
|
|
const settings = require('../lib/util/settings');
|
|
const stringify = require('json-stable-stringify-without-jsonify');
|
|
const logger = require('./stub/logger');
|
|
const zigbeeHerdsman = require('./stub/zigbeeHerdsman');
|
|
const flushPromises = require('./lib/flushPromises');
|
|
const MQTT = require('./stub/mqtt');
|
|
const Controller = require('../lib/controller');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
|
|
describe('HomeAssistant extension', () => {
|
|
let version;
|
|
let controller;
|
|
let extension;
|
|
let origin;
|
|
|
|
let resetExtension = async () => {
|
|
await controller.enableDisableExtension(false, 'HomeAssistant');
|
|
MQTT.publish.mockClear();
|
|
await controller.enableDisableExtension(true, 'HomeAssistant');
|
|
extension = controller.extensions.find((e) => e.constructor.name === 'HomeAssistant');
|
|
}
|
|
|
|
beforeEach(async () => {
|
|
data.writeDefaultConfiguration();
|
|
settings.reRead();
|
|
settings.set(['homeassistant'], true);
|
|
data.writeEmptyState();
|
|
controller.state.load();
|
|
await resetExtension();
|
|
});
|
|
|
|
beforeAll(async () => {
|
|
version = await require('../lib/util/utils').default.getZigbee2MQTTVersion();
|
|
origin = {name: 'Zigbee2MQTT', sw: version.version, url: 'https://www.zigbee2mqtt.io'}
|
|
version = `Zigbee2MQTT ${version.version}`;
|
|
jest.useFakeTimers();
|
|
settings.set(['homeassistant'], true);
|
|
data.writeDefaultConfiguration();
|
|
settings.reRead();
|
|
data.writeEmptyState();
|
|
MQTT.publish.mockClear();
|
|
controller = new Controller(false);
|
|
await controller.start();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
jest.useRealTimers();
|
|
});
|
|
|
|
it('Should not have duplicate type/object_ids in a mapping', () => {
|
|
const duplicated = [];
|
|
require('zigbee-herdsman-converters').devices.forEach((d) => {
|
|
const exposes = typeof d.exposes == 'function' ? d.exposes() : d.exposes;
|
|
const device = {definition: d, isDevice: () => true, options: {}, exposes: () => exposes};
|
|
const configs = extension.getConfigs(device);
|
|
const cfg_type_object_ids = [];
|
|
|
|
configs.forEach((c) => {
|
|
const id = c['type'] + '/' + c['object_id'];
|
|
if (cfg_type_object_ids.includes(id)) {
|
|
// A dynamic function must exposes all possible attributes for the docs
|
|
if (typeof d.exposes != 'function') {
|
|
duplicated.push(d.model);
|
|
}
|
|
} else {
|
|
cfg_type_object_ids.push(id);
|
|
}
|
|
});
|
|
});
|
|
|
|
expect(duplicated).toHaveLength(0);
|
|
});
|
|
|
|
it('Should discover devices and groups', async () => {
|
|
let payload;
|
|
await flushPromises();
|
|
|
|
payload = {
|
|
"availability":[{"topic":"zigbee2mqtt/bridge/state"}],
|
|
"brightness":true,
|
|
"brightness_scale":254,
|
|
"color_mode":true,
|
|
"command_topic":"zigbee2mqtt/ha_discovery_group/set",
|
|
"device":{
|
|
"identifiers":["zigbee2mqtt_1221051039810110150109113116116_9"],
|
|
"name":"ha_discovery_group",
|
|
"sw_version": version,
|
|
},
|
|
"max_mireds": 454,
|
|
"min_mireds": 250,
|
|
"json_attributes_topic":"zigbee2mqtt/ha_discovery_group",
|
|
"name":null,
|
|
"schema":"json",
|
|
"state_topic":"zigbee2mqtt/ha_discovery_group",
|
|
"supported_color_modes":[
|
|
"xy",
|
|
"color_temp"
|
|
],
|
|
"effect":true,
|
|
"effect_list":[
|
|
"blink",
|
|
"breathe",
|
|
"okay",
|
|
"channel_change",
|
|
"candle",
|
|
"fireplace",
|
|
"colorloop",
|
|
"finish_effect",
|
|
"stop_effect",
|
|
"stop_hue_effect",
|
|
],
|
|
"object_id":"ha_discovery_group",
|
|
"unique_id":"9_light_zigbee2mqtt",
|
|
'origin': origin,
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/light/1221051039810110150109113116116_9/light/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
"availability":[{"topic":"zigbee2mqtt/bridge/state"}],
|
|
"command_topic":"zigbee2mqtt/ha_discovery_group/set",
|
|
"device":{
|
|
"identifiers":["zigbee2mqtt_1221051039810110150109113116116_9"],
|
|
"name":"ha_discovery_group",
|
|
"sw_version": version,
|
|
},
|
|
"json_attributes_topic":"zigbee2mqtt/ha_discovery_group",
|
|
"name":null,
|
|
"payload_off":"OFF",
|
|
"payload_on":"ON",
|
|
"state_topic":"zigbee2mqtt/ha_discovery_group",
|
|
"object_id":"ha_discovery_group",
|
|
"unique_id":"9_switch_zigbee2mqtt",
|
|
'origin': origin,
|
|
"value_template":"{{ value_json.state }}"
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/switch/1221051039810110150109113116116_9/switch/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
'unit_of_measurement': '°C',
|
|
'device_class': 'temperature',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.temperature }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'object_id': 'weather_sensor_temperature',
|
|
'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
|
|
'origin': origin,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
'enabled_by_default': true,
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
'unit_of_measurement': '%',
|
|
'device_class': 'humidity',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.humidity }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'object_id': 'weather_sensor_humidity',
|
|
'unique_id': '0x0017880104e45522_humidity_zigbee2mqtt',
|
|
'origin': origin,
|
|
'enabled_by_default': true,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/humidity/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
'unit_of_measurement': 'hPa',
|
|
'device_class': 'atmospheric_pressure',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.pressure }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'object_id': 'weather_sensor_pressure',
|
|
'unique_id': '0x0017880104e45522_pressure_zigbee2mqtt',
|
|
'origin': origin,
|
|
'enabled_by_default': true,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/pressure/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
'unit_of_measurement': '%',
|
|
'device_class': 'battery',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.battery }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'object_id': 'weather_sensor_battery',
|
|
'unique_id': '0x0017880104e45522_battery_zigbee2mqtt',
|
|
'origin': origin,
|
|
'enabled_by_default': true,
|
|
'entity_category': 'diagnostic',
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/battery/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
'icon': 'mdi:signal',
|
|
'enabled_by_default': false,
|
|
'entity_category': 'diagnostic',
|
|
'unit_of_measurement': 'lqi',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.linkquality }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'name': 'Linkquality',
|
|
'object_id': 'weather_sensor_linkquality',
|
|
'unique_id': '0x0017880104e45522_linkquality_zigbee2mqtt',
|
|
'origin': origin,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/linkquality/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
"availability":[{"topic":"zigbee2mqtt/bridge/state"}],
|
|
"command_topic":"zigbee2mqtt/wall_switch_double/left/set",
|
|
"device":{
|
|
"identifiers":[
|
|
"zigbee2mqtt_0x0017880104e45542"
|
|
],
|
|
"manufacturer":"Xiaomi",
|
|
"model":"Aqara double key wired wall switch without neutral wire. Doesn't work as a router and doesn't support power meter (QBKG03LM)",
|
|
"name":"wall_switch_double",
|
|
"sw_version": null
|
|
},
|
|
"json_attributes_topic":"zigbee2mqtt/wall_switch_double",
|
|
"name":"Left",
|
|
"payload_off":"OFF",
|
|
"payload_on":"ON",
|
|
"state_topic":"zigbee2mqtt/wall_switch_double",
|
|
"object_id":"wall_switch_double_left",
|
|
"unique_id":"0x0017880104e45542_switch_left_zigbee2mqtt",
|
|
'origin': origin,
|
|
"value_template":"{{ value_json.state_left }}"
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/switch/0x0017880104e45542/switch_left/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
"availability":[{"topic":"zigbee2mqtt/bridge/state"}],
|
|
"command_topic":"zigbee2mqtt/wall_switch_double/right/set",
|
|
"device":{
|
|
"identifiers":[
|
|
"zigbee2mqtt_0x0017880104e45542"
|
|
],
|
|
"manufacturer":"Xiaomi",
|
|
"model":"Aqara double key wired wall switch without neutral wire. Doesn't work as a router and doesn't support power meter (QBKG03LM)",
|
|
"name":"wall_switch_double",
|
|
"sw_version": null
|
|
},
|
|
"json_attributes_topic":"zigbee2mqtt/wall_switch_double",
|
|
"name":"Right",
|
|
"payload_off":"OFF",
|
|
"payload_on":"ON",
|
|
"state_topic":"zigbee2mqtt/wall_switch_double",
|
|
"object_id":"wall_switch_double_right",
|
|
"unique_id":"0x0017880104e45542_switch_right_zigbee2mqtt",
|
|
'origin': origin,
|
|
"value_template":"{{ value_json.state_right }}"
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/switch/0x0017880104e45542/switch_right/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
"availability":[{"topic":"zigbee2mqtt/bridge/state"}],
|
|
"brightness":true,
|
|
"brightness_scale":254,
|
|
"color_mode": true,
|
|
"supported_color_modes": ["color_temp"],
|
|
"min_mireds": 250,
|
|
"max_mireds": 454,
|
|
"command_topic":"zigbee2mqtt/bulb/set",
|
|
"device":{
|
|
"identifiers":[
|
|
"zigbee2mqtt_0x000b57fffec6a5b2"
|
|
],
|
|
"manufacturer":"IKEA",
|
|
"model":"TRADFRI LED bulb E26/E27 980 lumen, dimmable, white spectrum, opal white (LED1545G12)",
|
|
"name":"bulb",
|
|
"sw_version": null,
|
|
},
|
|
"effect":true,
|
|
"effect_list":[
|
|
"blink",
|
|
"breathe",
|
|
"okay",
|
|
"channel_change",
|
|
"finish_effect",
|
|
"stop_effect"
|
|
],
|
|
"json_attributes_topic":"zigbee2mqtt/bulb",
|
|
"name":null,
|
|
"schema":"json",
|
|
"state_topic":"zigbee2mqtt/bulb",
|
|
"object_id":"bulb",
|
|
"unique_id":"0x000b57fffec6a5b2_light_zigbee2mqtt",
|
|
'origin': origin,
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/light/0x000b57fffec6a5b2/light/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover devices with precision', async () => {
|
|
settings.set(['devices', '0x0017880104e45522'], {
|
|
humidity_precision: 0,
|
|
temperature_precision: 1,
|
|
pressure_precision: 2,
|
|
friendly_name: 'weather_sensor',
|
|
retain: false,
|
|
})
|
|
|
|
await resetExtension();
|
|
|
|
let payload;
|
|
await flushPromises();
|
|
|
|
payload = {
|
|
'unit_of_measurement': '°C',
|
|
'device_class': 'temperature',
|
|
'state_class': 'measurement',
|
|
'enabled_by_default': true,
|
|
'value_template': "{{ value_json.temperature }}",
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'object_id': 'weather_sensor_temperature',
|
|
'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
|
|
'origin': origin,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
'unit_of_measurement': '%',
|
|
'device_class': 'humidity',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.humidity }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'object_id': 'weather_sensor_humidity',
|
|
'unique_id': '0x0017880104e45522_humidity_zigbee2mqtt',
|
|
'origin': origin,
|
|
'enabled_by_default': true,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/humidity/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
'unit_of_measurement': 'hPa',
|
|
'device_class': 'atmospheric_pressure',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.pressure }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'enabled_by_default': true,
|
|
'object_id': 'weather_sensor_pressure',
|
|
'unique_id': '0x0017880104e45522_pressure_zigbee2mqtt',
|
|
'origin': origin,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/pressure/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover devices with overriden user configuration', async () => {
|
|
settings.set(['devices', '0x0017880104e45522'], {
|
|
homeassistant: {
|
|
expire_after: 30,
|
|
icon: 'mdi:test',
|
|
temperature: {
|
|
expire_after: 90,
|
|
device: {
|
|
manufacturer: 'From Xiaomi',
|
|
sw_version: 'test'
|
|
}
|
|
},
|
|
humidity: {
|
|
unique_id: null,
|
|
},
|
|
device: {
|
|
manufacturer: 'Not from Xiaomi',
|
|
model: 'custom model',
|
|
},
|
|
},
|
|
friendly_name: 'weather_sensor',
|
|
retain: false,
|
|
})
|
|
|
|
await resetExtension();
|
|
|
|
let payload;
|
|
await flushPromises();
|
|
|
|
payload = {
|
|
'unit_of_measurement': '°C',
|
|
'device_class': 'temperature',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.temperature }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'enabled_by_default': true,
|
|
'object_id': 'weather_sensor_temperature',
|
|
'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
|
|
'origin': origin,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': 'test',
|
|
'model': 'custom model',
|
|
'manufacturer': 'From Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
'expire_after': 90,
|
|
'icon': 'mdi:test',
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
'unit_of_measurement': '%',
|
|
'device_class': 'humidity',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.humidity }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'enabled_by_default': true,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'custom model',
|
|
'manufacturer': 'Not from Xiaomi',
|
|
},
|
|
'origin': origin,
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
'expire_after': 30,
|
|
'icon': 'mdi:test',
|
|
'object_id': 'weather_sensor_humidity'
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/humidity/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover devices with overriden name', async () => {
|
|
settings.set(['devices', '0x0017880104e45522'], {
|
|
homeassistant: {
|
|
name: "Weather Sensor",
|
|
},
|
|
friendly_name: 'weather_sensor',
|
|
retain: false,
|
|
})
|
|
|
|
await resetExtension();
|
|
|
|
let payload;
|
|
await flushPromises();
|
|
|
|
payload = {
|
|
'unit_of_measurement': '°C',
|
|
'device_class': 'temperature',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.temperature }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'object_id': 'weather_sensor_temperature',
|
|
'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
|
|
'origin': origin,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'Weather Sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
'enabled_by_default': true,
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
'unit_of_measurement': '%',
|
|
'device_class': 'humidity',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.humidity }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'object_id': 'weather_sensor_humidity',
|
|
'unique_id': '0x0017880104e45522_humidity_zigbee2mqtt',
|
|
'origin': origin,
|
|
'enabled_by_default': true,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'Weather Sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/humidity/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover devices with overriden user configuration affecting type and object_id', async () => {
|
|
settings.set(['devices', '0x0017880104e45541'], {
|
|
friendly_name: 'my_switch',
|
|
homeassistant: {
|
|
switch: {
|
|
type: 'light',
|
|
object_id: 'light'
|
|
},
|
|
light: {
|
|
type: 'this should be ignored',
|
|
name: 'my_light_name_override'
|
|
},
|
|
},
|
|
})
|
|
|
|
await resetExtension();
|
|
|
|
let payload;
|
|
await flushPromises();
|
|
|
|
payload = {
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
"command_topic": "zigbee2mqtt/my_switch/set",
|
|
"device": {
|
|
"identifiers": [
|
|
"zigbee2mqtt_0x0017880104e45541"
|
|
],
|
|
"manufacturer": "Xiaomi",
|
|
"model": "Aqara single key wired wall switch without neutral wire. Doesn't work as a router and doesn't support power meter (QBKG04LM)",
|
|
"name": "my_switch",
|
|
"sw_version": null
|
|
},
|
|
"json_attributes_topic": "zigbee2mqtt/my_switch",
|
|
"name": "my_light_name_override",
|
|
"payload_off": "OFF",
|
|
"payload_on": "ON",
|
|
"state_topic": "zigbee2mqtt/my_switch",
|
|
"object_id": "my_switch",
|
|
"unique_id": "0x0017880104e45541_light_zigbee2mqtt",
|
|
'origin': origin,
|
|
"value_template": "{{ value_json.state }}"
|
|
}
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/light/0x0017880104e45541/light/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
});
|
|
|
|
it('Shouldnt discover devices when homeassistant null is set in device options', async () => {
|
|
settings.set(['devices', '0x0017880104e45522'], {
|
|
homeassistant: null,
|
|
friendly_name: 'weather_sensor',
|
|
retain: false,
|
|
})
|
|
|
|
await resetExtension();
|
|
await flushPromises();
|
|
|
|
const topics = MQTT.publish.mock.calls.map((c) => c[0]);
|
|
expect(topics).not.toContain('homeassistant/sensor/0x0017880104e45522/humidity/config')
|
|
expect(topics).not.toContain('homeassistant/sensor/0x0017880104e45522/temperature/config')
|
|
});
|
|
|
|
it('Shouldnt discover sensor when set to null', async () => {
|
|
logger.error.mockClear();
|
|
settings.set(['devices', '0x0017880104e45522'], {
|
|
homeassistant: {humidity: null},
|
|
friendly_name: 'weather_sensor',
|
|
retain: false,
|
|
})
|
|
|
|
await resetExtension();
|
|
|
|
const topics = MQTT.publish.mock.calls.map((c) => c[0]);
|
|
expect(topics).not.toContain('homeassistant/sensor/0x0017880104e45522/humidity/config')
|
|
expect(topics).toContain('homeassistant/sensor/0x0017880104e45522/temperature/config')
|
|
});
|
|
|
|
it('Should discover devices with fan', async () => {
|
|
let payload;
|
|
|
|
payload = {
|
|
"state_topic":"zigbee2mqtt/fan",
|
|
"state_value_template":"{{ value_json.fan_state }}",
|
|
"command_topic":"zigbee2mqtt/fan/set/fan_state",
|
|
"percentage_state_topic":"zigbee2mqtt/fan",
|
|
"percentage_command_topic":"zigbee2mqtt/fan/set/fan_mode",
|
|
"percentage_value_template":"{{ {'off':0, 'low':1, 'medium':2, 'high':3, 'on':4}[value_json.fan_mode] | default('None') }}",
|
|
"percentage_command_template":"{{ {0:'off', 1:'low', 2:'medium', 3:'high', 4:'on'}[value] | default('') }}",
|
|
"preset_mode_state_topic":"zigbee2mqtt/fan",
|
|
"preset_mode_command_topic":"zigbee2mqtt/fan/set/fan_mode",
|
|
"preset_mode_value_template":"{{ value_json.fan_mode if value_json.fan_mode in ['smart'] else 'None' | default('None') }}",
|
|
"preset_modes":[
|
|
"smart"
|
|
],
|
|
"speed_range_min":1,
|
|
"speed_range_max":4,
|
|
"json_attributes_topic":"zigbee2mqtt/fan",
|
|
"name":null,
|
|
"object_id": "fan",
|
|
"unique_id":"0x0017880104e45548_fan_zigbee2mqtt",
|
|
'origin': origin,
|
|
"device":{
|
|
"identifiers":[
|
|
"zigbee2mqtt_0x0017880104e45548"
|
|
],
|
|
"name":"fan",
|
|
"sw_version": null,
|
|
"model":"Universal wink enabled white ceiling fan premier remote control (99432)",
|
|
"manufacturer":"Hampton Bay"
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/fan/0x0017880104e45548/fan/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover thermostat devices', async () => {
|
|
let payload;
|
|
|
|
payload = {
|
|
"action_template":"{% set values = {None:None,'idle':'off','heat':'heating','cool':'cooling','fan_only':'fan'} %}{{ values[value_json.running_state] }}",
|
|
"action_topic":"zigbee2mqtt/TS0601_thermostat",
|
|
"availability":[
|
|
{
|
|
"topic":"zigbee2mqtt/bridge/state"
|
|
}
|
|
],
|
|
"current_temperature_template":"{{ value_json.local_temperature }}",
|
|
"current_temperature_topic":"zigbee2mqtt/TS0601_thermostat",
|
|
"device":{
|
|
"identifiers":[
|
|
"zigbee2mqtt_0x0017882104a44559"
|
|
],
|
|
"manufacturer":"TuYa",
|
|
"model":"Radiator valve with thermostat (TS0601_thermostat)",
|
|
"name":"TS0601_thermostat",
|
|
"sw_version":null
|
|
},
|
|
"preset_mode_command_topic":"zigbee2mqtt/TS0601_thermostat/set/preset",
|
|
"preset_modes":[
|
|
"schedule",
|
|
"manual",
|
|
"boost",
|
|
"complex",
|
|
"comfort",
|
|
"eco",
|
|
"away"
|
|
],
|
|
"preset_mode_value_template":"{{ value_json.preset }}",
|
|
"preset_mode_state_topic":"zigbee2mqtt/TS0601_thermostat",
|
|
"json_attributes_topic":"zigbee2mqtt/TS0601_thermostat",
|
|
"max_temp":"35",
|
|
"min_temp":"5",
|
|
"mode_command_topic":"zigbee2mqtt/TS0601_thermostat/set/system_mode",
|
|
"mode_state_template":"{{ value_json.system_mode }}",
|
|
"mode_state_topic":"zigbee2mqtt/TS0601_thermostat",
|
|
"modes":[
|
|
"heat",
|
|
"auto",
|
|
"off"
|
|
],
|
|
"name":null,
|
|
"temp_step":0.5,
|
|
"temperature_command_topic":"zigbee2mqtt/TS0601_thermostat/set/current_heating_setpoint",
|
|
"temperature_state_template":"{{ value_json.current_heating_setpoint }}",
|
|
"temperature_state_topic":"zigbee2mqtt/TS0601_thermostat",
|
|
"temperature_unit":"C",
|
|
"object_id": "ts0601_thermostat",
|
|
"unique_id":"0x0017882104a44559_climate_zigbee2mqtt",
|
|
'origin': origin,
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/climate/0x0017882104a44559/climate/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover devices with cover_position', async () => {
|
|
let payload;
|
|
|
|
payload = {
|
|
command_topic: 'zigbee2mqtt/smart vent/set',
|
|
position_topic: 'zigbee2mqtt/smart vent',
|
|
set_position_topic: 'zigbee2mqtt/smart vent/set',
|
|
set_position_template: '{ "position": {{ position }} }',
|
|
position_template: '{{ value_json.position }}',
|
|
state_topic: 'zigbee2mqtt/smart vent',
|
|
value_template: `{{ value_json.state }}`,
|
|
state_open: 'OPEN',
|
|
state_closed: 'CLOSE',
|
|
state_stopped: 'STOP',
|
|
json_attributes_topic: 'zigbee2mqtt/smart vent',
|
|
name: null,
|
|
object_id: 'smart_vent',
|
|
unique_id: '0x0017880104e45551_cover_zigbee2mqtt',
|
|
'origin': origin,
|
|
device:
|
|
{
|
|
identifiers: [ 'zigbee2mqtt_0x0017880104e45551' ],
|
|
name: 'smart vent',
|
|
sw_version: null,
|
|
model: 'Smart vent (SV01)',
|
|
manufacturer: 'Keen Home'
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/cover/0x0017880104e45551/cover/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
payload = {
|
|
"availability": [{ "topic": "zigbee2mqtt/bridge/state" }],
|
|
"command_topic": "zigbee2mqtt/zigfred_plus/l6/set",
|
|
"device": {
|
|
"identifiers": ["zigbee2mqtt_0xf4ce368a38be56a1"],
|
|
"manufacturer": "Siglis",
|
|
"model": "zigfred plus smart in-wall switch (ZFP-1A-CH)",
|
|
"name": "zigfred_plus",
|
|
"sw_version": null
|
|
},
|
|
"json_attributes_topic": "zigbee2mqtt/zigfred_plus/l6",
|
|
"name": "L6",
|
|
"position_template": "{{ value_json.position }}",
|
|
"position_topic": "zigbee2mqtt/zigfred_plus/l6",
|
|
"set_position_template": "{ \"position_l6\": {{ position }} }",
|
|
"set_position_topic": "zigbee2mqtt/zigfred_plus/l6/set",
|
|
"state_stopped": 'STOP',
|
|
"state_closed": "CLOSE",
|
|
"state_open": "OPEN",
|
|
"state_topic": "zigbee2mqtt/zigfred_plus/l6",
|
|
"tilt_command_topic": "zigbee2mqtt/zigfred_plus/l6/set/tilt",
|
|
"tilt_status_template": "{{ value_json.tilt }}",
|
|
"tilt_status_topic": "zigbee2mqtt/zigfred_plus/l6",
|
|
"object_id": "zigfred_plus_l6",
|
|
"unique_id": "0xf4ce368a38be56a1_cover_l6_zigbee2mqtt",
|
|
'origin': origin,
|
|
"value_template": "{{ value_json.state }}"
|
|
}
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/cover/0xf4ce368a38be56a1/cover_l6/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover devices with custom homeassistant_discovery_topic', async () => {
|
|
settings.set(['advanced', 'homeassistant_discovery_topic'], 'my_custom_discovery_topic')
|
|
await resetExtension();
|
|
|
|
let payload;
|
|
|
|
payload = {
|
|
'unit_of_measurement': '°C',
|
|
'device_class': 'temperature',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.temperature }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'enabled_by_default': true,
|
|
'object_id': 'weather_sensor_temperature',
|
|
'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
|
|
'origin': origin,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'my_custom_discovery_topic/sensor/0x0017880104e45522/temperature/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should throw error when starting with attributes output', async () => {
|
|
settings.set(['experimental', 'output'], 'attribute')
|
|
settings.set(['homeassistant'], true)
|
|
expect(() => {
|
|
const controller = new Controller(false);
|
|
}).toThrowError('Home Assistant integration is not possible with attribute output!');
|
|
});
|
|
|
|
it('Should warn when starting with cache_state false', async () => {
|
|
settings.set(['advanced', 'cache_state'], false);
|
|
logger.warn.mockClear();
|
|
await resetExtension();
|
|
expect(logger.warn).toHaveBeenCalledWith("In order for Home Assistant integration to work properly set `cache_state: true");
|
|
});
|
|
|
|
it('Should set missing values to null', async () => {
|
|
// https://github.com/Koenkk/zigbee2mqtt/issues/6987
|
|
const device = zigbeeHerdsman.devices.WSDCGQ11LM;
|
|
const data = {measuredValue: -85}
|
|
const payload = {data, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
|
|
MQTT.publish.mockClear();
|
|
await zigbeeHerdsman.events.message(payload);
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(1);
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/weather_sensor',
|
|
stringify({"battery":null,"humidity":null,"linkquality":null,"pressure":null,"temperature":-0.85,"voltage":null}),
|
|
{ retain: false, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should copy hue/saturtion to h/s if present', async () => {
|
|
const device = zigbeeHerdsman.devices.bulb_color;
|
|
const data = {currentHue: 0, currentSaturation: 254}
|
|
const payload = {data, cluster: 'lightingColorCtrl', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
|
|
MQTT.publish.mockClear();
|
|
await zigbeeHerdsman.events.message(payload);
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(1);
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/bulb_color',
|
|
stringify({"color":{"hue": 0, "saturation": 100, "h": 0, "s": 100}, "color_mode": "hs", "linkquality": null, "state": null, "update_available": null, "power_on_behavior":null, "update": {"state": null, "installed_version": -1, "latest_version": -1}}),
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should not copy hue/saturtion if properties are missing', async () => {
|
|
const device = zigbeeHerdsman.devices.bulb_color;
|
|
const data = {currentX: 29991, currentY: 26872};
|
|
const payload = {data, cluster: 'lightingColorCtrl', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
|
|
MQTT.publish.mockClear();
|
|
await zigbeeHerdsman.events.message(payload);
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(1);
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/bulb_color',
|
|
stringify({"color": {"x": 0.4576,"y": 0.41}, "color_mode": "xy", "linkquality": null,"state": null, "update_available": null, "power_on_behavior":null, "update": {"state": null, "installed_version": -1, "latest_version": -1}}),
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should not copy hue/saturtion if color is missing', async () => {
|
|
const device = zigbeeHerdsman.devices.bulb_color;
|
|
const data = {onOff: 1}
|
|
const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
|
|
MQTT.publish.mockClear();
|
|
await zigbeeHerdsman.events.message(payload);
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(1);
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/bulb_color',
|
|
stringify({"linkquality": null,"state": "ON", "update_available": null, "power_on_behavior": null, "update": {"state": null, "installed_version": -1, "latest_version": -1}}),
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Shouldt discover when already discovered', async () => {
|
|
const device = zigbeeHerdsman.devices.WSDCGQ11LM;
|
|
const data = {measuredValue: -85}
|
|
const payload = {data, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
|
|
MQTT.publish.mockClear();
|
|
await zigbeeHerdsman.events.message(payload);
|
|
await flushPromises();
|
|
// 1 publish is the publish from receive
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('Should discover when not discovered yet', async () => {
|
|
controller.extensions.find((e) => e.constructor.name === 'HomeAssistant').discovered = {};
|
|
const device = zigbeeHerdsman.devices.WSDCGQ11LM;
|
|
const data = {measuredValue: -85}
|
|
const payload = {data, cluster: 'msTemperatureMeasurement', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
|
|
MQTT.publish.mockClear();
|
|
await zigbeeHerdsman.events.message(payload);
|
|
await flushPromises();
|
|
const payloadHA = {
|
|
'unit_of_measurement': '°C',
|
|
'device_class': 'temperature',
|
|
'enabled_by_default': true,
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.temperature }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'object_id': 'weather_sensor_temperature',
|
|
'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
|
|
'origin': origin,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
stringify(payloadHA),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Shouldnt discover when device leaves', async () => {
|
|
controller.extensions.find((e) => e.constructor.name === 'HomeAssistant').discovered = {};
|
|
const device = zigbeeHerdsman.devices.bulb;
|
|
const payload = {ieeeAddr: device.ieeeAddr};
|
|
MQTT.publish.mockClear();
|
|
await zigbeeHerdsman.events.deviceLeave(payload);
|
|
await flushPromises();
|
|
});
|
|
|
|
it('Should discover when options change', async () => {
|
|
const device = controller.zigbee.resolveEntity(zigbeeHerdsman.devices.bulb);
|
|
MQTT.publish.mockClear();
|
|
controller.eventBus.emitEntityOptionsChanged({entity: device, from: {}, to: {'test': 123}});
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
`homeassistant/light/${device.ID}/light/config`,
|
|
expect.any(String),
|
|
expect.any(Object),
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should send all status when home assistant comes online (default topic)', async () => {
|
|
data.writeDefaultState();
|
|
extension.state.load();
|
|
await resetExtension();
|
|
expect(MQTT.subscribe).toHaveBeenCalledWith('homeassistant/status');
|
|
await flushPromises();
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/status', 'online');
|
|
await flushPromises();
|
|
jest.runOnlyPendingTimers();
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/bulb',
|
|
stringify({"state":"ON","brightness":50,"color_temp":370,"linkquality":99,"power_on_behavior":null, "update_available": null, "update": {"state": null, "installed_version": -1, "latest_version": -1}}),
|
|
{ retain: true, qos: 0 },
|
|
expect.any(Function)
|
|
);
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/remote',
|
|
stringify({"action":null,"action_duration":null,"battery":null,"brightness":255,"linkquality":null, "update_available": null, "update": {"state": null, "installed_version": -1, "latest_version": -1}}),
|
|
{ retain: true, qos: 0 },
|
|
expect.any(Function)
|
|
);
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/group_1',
|
|
stringify({"state":'ON'}),
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function)
|
|
);
|
|
});
|
|
|
|
it('Should send all status when home assistant comes online', async () => {
|
|
data.writeDefaultState();
|
|
extension.state.load();
|
|
await resetExtension();
|
|
expect(MQTT.subscribe).toHaveBeenCalledWith('hass/status');
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('hass/status', 'online');
|
|
await flushPromises();
|
|
jest.runOnlyPendingTimers();
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/bulb',
|
|
stringify({"state":"ON","brightness":50,"color_temp":370,"linkquality":99,"power_on_behavior":null, "update_available": null, "update": {"state": null, "installed_version": -1, "latest_version": -1}}),
|
|
{ retain: true, qos: 0 },
|
|
expect.any(Function)
|
|
);
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/remote',
|
|
stringify({"action":null,"action_duration":null,"battery":null,"brightness":255,"linkquality":null, "update_available": null, "update": {"state": null, "installed_version": -1, "latest_version": -1}}),
|
|
{ retain: true, qos: 0 },
|
|
expect.any(Function)
|
|
);
|
|
});
|
|
|
|
it('Shouldnt send all status when home assistant comes offline', async () => {
|
|
data.writeDefaultState();
|
|
extension.state.load();
|
|
await resetExtension();
|
|
await flushPromises();
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('hass/status', 'offline');
|
|
await flushPromises();
|
|
jest.runOnlyPendingTimers();
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(0);
|
|
});
|
|
|
|
it('Shouldnt send all status when home assistant comes online with different topic', async () => {
|
|
data.writeDefaultState();
|
|
extension.state.load();
|
|
await resetExtension();
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('hass/status_different', 'offline');
|
|
await flushPromises();
|
|
jest.runOnlyPendingTimers();
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(0);
|
|
});
|
|
|
|
it('Should discover devices with availability', async () => {
|
|
settings.set(['availability'], true)
|
|
await resetExtension();
|
|
|
|
let payload;
|
|
|
|
payload = {
|
|
'unit_of_measurement': '°C',
|
|
'device_class': 'temperature',
|
|
'enabled_by_default': true,
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.temperature }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'object_id': 'weather_sensor_temperature',
|
|
'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
|
|
'origin': origin,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability_mode': 'all',
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}, {topic: 'zigbee2mqtt/weather_sensor/availability'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should clear discovery when device is removed', async () => {
|
|
MQTT.publish.mockClear();
|
|
MQTT.events.message('zigbee2mqtt/bridge/config/remove', 'weather_sensor');
|
|
await flushPromises();
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
null,
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/humidity/config',
|
|
null,
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/pressure/config',
|
|
null,
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/battery/config',
|
|
null,
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/linkquality/config',
|
|
null,
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should not clear discovery when unsupported device is removed', async () => {
|
|
MQTT.publish.mockClear();
|
|
MQTT.events.message('zigbee2mqtt/bridge/config/remove', 'unsupported2');
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('Should refresh discovery when device is renamed', async () => {
|
|
await MQTT.events.message('homeassistant/device_automation/0x0017880104e45522/action_double/config', stringify({topic: 'zigbee2mqtt/weather_sensor/action'}));
|
|
await flushPromises();
|
|
MQTT.publish.mockClear();
|
|
MQTT.events.message('zigbee2mqtt/bridge/request/device/rename', stringify({"from": "weather_sensor", "to": "weather_sensor_renamed","homeassistant_rename":true}));
|
|
await flushPromises();
|
|
jest.runOnlyPendingTimers();
|
|
await flushPromises();
|
|
|
|
const payload = {
|
|
'unit_of_measurement': '°C',
|
|
'device_class': 'temperature',
|
|
'state_class': 'measurement',
|
|
'enabled_by_default': true,
|
|
'value_template': '{{ value_json.temperature }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor_renamed',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor_renamed',
|
|
'object_id': 'weather_sensor_renamed_temperature',
|
|
'origin': origin,
|
|
'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor_renamed',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
null,
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/device_automation/0x0017880104e45522/action_double/config',
|
|
stringify({
|
|
"automation_type":"trigger",
|
|
"type":"action",
|
|
"subtype":"double",
|
|
"payload":"double",
|
|
"topic":"zigbee2mqtt/weather_sensor_renamed/action",
|
|
'origin': origin,
|
|
"device":{
|
|
"identifiers":[
|
|
"zigbee2mqtt_0x0017880104e45522"
|
|
],
|
|
"name":"weather_sensor_renamed",
|
|
"sw_version": null,
|
|
"model":"Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)",
|
|
"manufacturer":"Xiaomi"
|
|
}
|
|
}),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should refresh discovery when group is renamed', async () => {
|
|
MQTT.publish.mockClear();
|
|
MQTT.events.message('zigbee2mqtt/bridge/request/group/rename', stringify({"from": "ha_discovery_group", "to": "ha_discovery_group_new","homeassistant_rename":true}));
|
|
await flushPromises();
|
|
jest.runOnlyPendingTimers();
|
|
await flushPromises();
|
|
|
|
const payload = {
|
|
"availability":[{"topic":"zigbee2mqtt/bridge/state"}],
|
|
"brightness":true,
|
|
"brightness_scale":254,
|
|
"color_mode":true,
|
|
"command_topic":"zigbee2mqtt/ha_discovery_group_new/set",
|
|
"device":{
|
|
"identifiers":["zigbee2mqtt_1221051039810110150109113116116_9"],
|
|
"name":"ha_discovery_group_new",
|
|
"sw_version": version,
|
|
},
|
|
"json_attributes_topic":"zigbee2mqtt/ha_discovery_group_new",
|
|
"max_mireds": 454,
|
|
"min_mireds": 250,
|
|
"name":null,
|
|
"schema":"json",
|
|
"state_topic":"zigbee2mqtt/ha_discovery_group_new",
|
|
"supported_color_modes":[
|
|
"xy",
|
|
"color_temp"
|
|
],
|
|
"effect":true,
|
|
"effect_list":[
|
|
"blink",
|
|
"breathe",
|
|
"okay",
|
|
"channel_change",
|
|
"candle",
|
|
"fireplace",
|
|
"colorloop",
|
|
"finish_effect",
|
|
"stop_effect",
|
|
"stop_hue_effect",
|
|
],
|
|
"object_id":"ha_discovery_group_new",
|
|
"unique_id":"9_light_zigbee2mqtt",
|
|
'origin': origin,
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/light/1221051039810110150109113116116_9/light/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/light/1221051039810110150109113116116_9/light/config',
|
|
null,
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Shouldnt refresh discovery when device is renamed and homeassistant_rename is false', async () => {
|
|
MQTT.publish.mockClear();
|
|
MQTT.events.message('zigbee2mqtt/bridge/request/device/rename', stringify({"from": "weather_sensor", "to": "weather_sensor_renamed","homeassistant_rename":false}));
|
|
await flushPromises();
|
|
|
|
expect(MQTT.publish).not.toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
null,
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
const payload = {
|
|
'unit_of_measurement': '°C',
|
|
'device_class': 'temperature',
|
|
'state_class': 'measurement',
|
|
'enabled_by_default': true,
|
|
'value_template': '{{ value_json.temperature }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor_renamed',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor_renamed',
|
|
'object_id': 'weather_sensor_renamed_temperature',
|
|
'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
|
|
'origin': origin,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor_renamed',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover update_available sensor when device supports it', async () => {
|
|
const payload = {
|
|
"payload_on":true,
|
|
"payload_off":false,
|
|
"value_template":`{{ value_json['update']['state'] == "available" }}`,
|
|
"enabled_by_default": false,
|
|
"state_topic":"zigbee2mqtt/bulb",
|
|
"json_attributes_topic":"zigbee2mqtt/bulb",
|
|
"name":null,
|
|
"object_id":"bulb_update_available",
|
|
"unique_id":"0x000b57fffec6a5b2_update_available_zigbee2mqtt",
|
|
'origin': origin,
|
|
"device":{
|
|
"identifiers":[
|
|
"zigbee2mqtt_0x000b57fffec6a5b2"
|
|
],
|
|
"name":"bulb",
|
|
'sw_version': null,
|
|
"model":"TRADFRI LED bulb E26/E27 980 lumen, dimmable, white spectrum, opal white (LED1545G12)",
|
|
"manufacturer":"IKEA"
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
'device_class': 'update',
|
|
'entity_category': 'diagnostic'
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/binary_sensor/0x000b57fffec6a5b2/update_available/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover trigger when click is published', async () => {
|
|
const discovered = MQTT.publish.mock.calls.filter((c) => c[0].includes('0x0017880104e45520')).map((c) => c[0]);
|
|
expect(discovered.length).toBe(7);
|
|
expect(discovered).toContain('homeassistant/sensor/0x0017880104e45520/click/config');
|
|
expect(discovered).toContain('homeassistant/sensor/0x0017880104e45520/action/config');
|
|
|
|
MQTT.publish.mockClear();
|
|
|
|
const device = zigbeeHerdsman.devices.WXKG11LM;
|
|
const payload1 = {data: {onOff: 1}, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
|
|
await zigbeeHerdsman.events.message(payload1);
|
|
await flushPromises();
|
|
|
|
const discoverPayloadAction = {
|
|
"automation_type":"trigger",
|
|
"type":"action",
|
|
"subtype":"single",
|
|
"payload":"single",
|
|
"topic":"zigbee2mqtt/button/action",
|
|
"origin": origin,
|
|
"device":{
|
|
"identifiers":[
|
|
"zigbee2mqtt_0x0017880104e45520"
|
|
],
|
|
"name":"button",
|
|
"sw_version": null,
|
|
"model":"Aqara wireless switch (WXKG11LM)",
|
|
"manufacturer":"Xiaomi"
|
|
}
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/device_automation/0x0017880104e45520/action_single/config',
|
|
stringify(discoverPayloadAction),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
const discoverPayloadClick = {
|
|
"automation_type":"trigger",
|
|
"type":"click",
|
|
"subtype":"single",
|
|
"payload":"single",
|
|
"topic":"zigbee2mqtt/button/click",
|
|
"origin": origin,
|
|
"device":{
|
|
"identifiers":[
|
|
"zigbee2mqtt_0x0017880104e45520"
|
|
],
|
|
"name":"button",
|
|
"sw_version": null,
|
|
"model":"Aqara wireless switch (WXKG11LM)",
|
|
"manufacturer":"Xiaomi"
|
|
}
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/device_automation/0x0017880104e45520/click_single/config',
|
|
stringify(discoverPayloadClick),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/button/action',
|
|
'single',
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/button/click',
|
|
'single',
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/button',
|
|
stringify({action: "single", click: "single", battery: null, linkquality: null, voltage: null, power_outage_count: null, device_temperature: null}),
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/button',
|
|
stringify({action: "", battery: null, linkquality: null, voltage: null, click: null, power_outage_count: null, device_temperature: null}),
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/button',
|
|
stringify({click: "", action: null, battery: null, linkquality: null, voltage: null, power_outage_count: null, device_temperature: null}),
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
// Should only discover it once
|
|
MQTT.publish.mockClear();
|
|
await zigbeeHerdsman.events.message(payload1);
|
|
await flushPromises();
|
|
expect(MQTT.publish).not.toHaveBeenCalledWith(
|
|
'homeassistant/device_automation/0x0017880104e45520/action_single/config',
|
|
stringify(discoverPayloadAction),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).not.toHaveBeenCalledWith(
|
|
'homeassistant/device_automation/0x0017880104e45520/click_single/config',
|
|
stringify(discoverPayloadClick),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/button/action',
|
|
'single',
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/button/click',
|
|
'single',
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
// Shouldn't rediscover when already discovered in previous session
|
|
controller.extensions.find((e) => e.constructor.name === 'HomeAssistant')._clearDiscoveredTrigger();
|
|
await MQTT.events.message('homeassistant/device_automation/0x0017880104e45520/action_double/config', stringify({topic: 'zigbee2mqtt/button/action'}));
|
|
await MQTT.events.message('homeassistant/device_automation/0x0017880104e45520/action_double/config', stringify({topic: 'zigbee2mqtt/button/action'}));
|
|
await flushPromises();
|
|
MQTT.publish.mockClear();
|
|
const payload2 = {data: {'32768': 2}, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
|
|
await zigbeeHerdsman.events.message(payload2);
|
|
await flushPromises();
|
|
expect(MQTT.publish).not.toHaveBeenCalledWith('homeassistant/device_automation/0x0017880104e45520/action_double/config', expect.any(String), expect.any(Object), expect.any(Function));
|
|
|
|
// Should rediscover when already discovered in previous session but with diferent name
|
|
controller.extensions.find((e) => e.constructor.name === 'HomeAssistant')._clearDiscoveredTrigger();
|
|
await MQTT.events.message('homeassistant/device_automation/0x0017880104e45520/action_double/config', stringify({topic: 'zigbee2mqtt/button_other_name/action'}));
|
|
await flushPromises();
|
|
MQTT.publish.mockClear();
|
|
await zigbeeHerdsman.events.message(payload2);
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledWith('homeassistant/device_automation/0x0017880104e45520/action_double/config', expect.any(String), expect.any(Object), expect.any(Function));
|
|
});
|
|
|
|
it('Should not discover device_automation when disabled', async () => {
|
|
settings.set(['device_options'], {
|
|
homeassistant: {device_automation: null},
|
|
})
|
|
await resetExtension();
|
|
MQTT.publish.mockClear();
|
|
|
|
const device = zigbeeHerdsman.devices.WXKG11LM;
|
|
const payload1 = {data: {onOff: 1}, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
|
|
await zigbeeHerdsman.events.message(payload1);
|
|
await flushPromises();
|
|
|
|
expect(MQTT.publish).not.toHaveBeenCalledWith(
|
|
'homeassistant/device_automation/0x0017880104e45520/action_single/config',
|
|
expect.any(String),
|
|
expect.any(Object),
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should not discover sensor_click when legacy: false is set', async () => {
|
|
settings.set(['devices', '0x0017880104e45520'], {
|
|
legacy: false,
|
|
friendly_name: 'weather_sensor',
|
|
retain: false,
|
|
})
|
|
await resetExtension();
|
|
|
|
const discovered = MQTT.publish.mock.calls.filter((c) => c[0].includes('0x0017880104e45520')).map((c) => c[0]);
|
|
expect(discovered.length).toBe(6);
|
|
expect(discovered).toContain('homeassistant/sensor/0x0017880104e45520/action/config');
|
|
expect(discovered).toContain('homeassistant/sensor/0x0017880104e45520/battery/config');
|
|
expect(discovered).toContain('homeassistant/sensor/0x0017880104e45520/linkquality/config');
|
|
});
|
|
|
|
it('Should disable Home Assistant legacy triggers', async () => {
|
|
settings.set(['advanced', 'homeassistant_legacy_triggers'], false);
|
|
await resetExtension();
|
|
|
|
const discovered = MQTT.publish.mock.calls.filter((c) => c[0].includes('0x0017880104e45520')).map((c) => c[0]);
|
|
expect(discovered.length).toBe(5);
|
|
expect(discovered).not.toContain('homeassistant/sensor/0x0017880104e45520/click/config');
|
|
expect(discovered).not.toContain('homeassistant/sensor/0x0017880104e45520/action/config');
|
|
|
|
MQTT.publish.mockClear();
|
|
|
|
const device = zigbeeHerdsman.devices.WXKG11LM;
|
|
settings.set(['devices', device.ieeeAddr, 'legacy'], false);
|
|
const payload = {data: {onOff: 1}, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
|
|
await zigbeeHerdsman.events.message(payload);
|
|
await flushPromises();
|
|
|
|
const discoverPayload = {
|
|
"automation_type":"trigger",
|
|
"type":"action",
|
|
"subtype":"single",
|
|
"payload":"single",
|
|
"topic":"zigbee2mqtt/button/action",
|
|
"origin": origin,
|
|
"device":{
|
|
"identifiers":[
|
|
"zigbee2mqtt_0x0017880104e45520"
|
|
],
|
|
"name":"button",
|
|
"sw_version": null,
|
|
"model":"Aqara wireless switch (WXKG11LM)",
|
|
"manufacturer":"Xiaomi"
|
|
}
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/device_automation/0x0017880104e45520/action_single/config',
|
|
stringify(discoverPayload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/button/action',
|
|
'single',
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'zigbee2mqtt/button',
|
|
stringify({action: "single", "battery":null,"linkquality":null,"voltage":null, "power_outage_count": null, "device_temperature": null}),
|
|
{ retain: false, qos: 0 },
|
|
expect.any(Function),
|
|
);
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(3);
|
|
});
|
|
|
|
it('Should republish payload to postfix topic with lightWithPostfix config', async () => {
|
|
MQTT.publish.mockClear();
|
|
|
|
await MQTT.events.message('zigbee2mqtt/U202DST600ZB/l2/set', stringify({state: 'ON', brightness: 20}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/U202DST600ZB', stringify({state_l2:"ON", brightness_l2:20, linkquality: null, state_l1: null}), {"qos": 0, "retain": false}, expect.any(Function));
|
|
expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/U202DST600ZB/l2', stringify({state:"ON", brightness:20}), {"qos": 0, "retain": false}, expect.any(Function));
|
|
expect(MQTT.publish).toHaveBeenCalledWith('zigbee2mqtt/U202DST600ZB/l1', stringify({state: null}), {"qos": 0, "retain": false}, expect.any(Function));
|
|
});
|
|
|
|
it('Shouldnt crash in onPublishEntityState on group publish', async () => {
|
|
logger.error.mockClear();
|
|
MQTT.publish.mockClear();
|
|
|
|
await MQTT.events.message('zigbee2mqtt/group_1/set', stringify({state: 'ON'}));
|
|
await flushPromises();
|
|
expect(logger.error).toHaveBeenCalledTimes(0);
|
|
});
|
|
|
|
it('Should counter an action payload with an empty payload', async () => {
|
|
MQTT.publish.mockClear();
|
|
const device = zigbeeHerdsman.devices.WXKG11LM;
|
|
settings.set(['devices', device.ieeeAddr, 'legacy'], false);
|
|
const data = {onOff: 1}
|
|
const payload = {data, cluster: 'genOnOff', device, endpoint: device.getEndpoint(1), type: 'attributeReport', linkquality: 10};
|
|
await zigbeeHerdsman.events.message(payload);
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(4);
|
|
expect(MQTT.publish.mock.calls[0][0]).toStrictEqual('zigbee2mqtt/button');
|
|
expect(JSON.parse(MQTT.publish.mock.calls[0][1])).toStrictEqual({action: 'single', click: null, battery: null, linkquality: null, voltage: null, power_outage_count: null, device_temperature: null});
|
|
expect(MQTT.publish.mock.calls[0][2]).toStrictEqual({"qos": 0, "retain": false});
|
|
expect(MQTT.publish.mock.calls[1][0]).toStrictEqual('zigbee2mqtt/button');
|
|
expect(JSON.parse(MQTT.publish.mock.calls[1][1])).toStrictEqual({action: '', click: null, battery: null, linkquality: null, voltage: null, power_outage_count: null, device_temperature: null});
|
|
expect(MQTT.publish.mock.calls[1][2]).toStrictEqual({"qos": 0, "retain": false});
|
|
expect(MQTT.publish.mock.calls[2][0]).toStrictEqual('homeassistant/device_automation/0x0017880104e45520/action_single/config');
|
|
expect(MQTT.publish.mock.calls[3][0]).toStrictEqual('zigbee2mqtt/button/action');
|
|
});
|
|
|
|
it('Should clear outdated configs', async () => {
|
|
// Non-existing group -> clear
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/light/1221051039810110150109113116116_91231/light/config', stringify({availability: [{topic: 'zigbee2mqtt/bridge/state'}]}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(1);
|
|
expect(MQTT.publish).toHaveBeenCalledWith('homeassistant/light/1221051039810110150109113116116_91231/light/config', null, {qos: 1, retain: true}, expect.any(Function));
|
|
|
|
// Existing group -> dont clear
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/light/1221051039810110150109113116116_9/light/config', stringify({availability: [{topic: 'zigbee2mqtt/bridge/state'}]}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(0);
|
|
|
|
// Existing group with old topic structure (1.20.0) -> clear
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/light/9/light/config', stringify({availability: [{topic: 'zigbee2mqtt/bridge/state'}]}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(1);
|
|
expect(MQTT.publish).toHaveBeenCalledWith('homeassistant/light/9/light/config', null, {qos: 1, retain: true}, expect.any(Function));
|
|
|
|
// Existing group, non existing config -> clear
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/light/1221051039810110150109113116116_9/switch/config', stringify({availability: [{topic: 'zigbee2mqtt/bridge/state'}]}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(1);
|
|
expect(MQTT.publish).toHaveBeenCalledWith('homeassistant/light/1221051039810110150109113116116_9/switch/config', null, {qos: 1, retain: true}, expect.any(Function));
|
|
|
|
// Non-existing device -> clear
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/sensor/0x123/temperature/config', stringify({availability: [{topic: 'zigbee2mqtt/bridge/state'}]}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(1);
|
|
expect(MQTT.publish).toHaveBeenCalledWith('homeassistant/sensor/0x123/temperature/config', null, {qos: 1, retain: true}, expect.any(Function));
|
|
|
|
// Existing device -> don't clear
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/binary_sensor/0x000b57fffec6a5b2/update_available/config', stringify({availability: [{topic: 'zigbee2mqtt/bridge/state'}]}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(0);
|
|
|
|
// Non-existing device of different instance -> don't clear
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/sensor/0x123/temperature/config', stringify({availability: [{topic: 'zigbee2mqtt_different/bridge/state'}]}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(0);
|
|
|
|
// Existing device but non-existing config -> don't clear
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/sensor/0x000b57fffec6a5b2/update_available/config', stringify({availability: [{topic: 'zigbee2mqtt/bridge/state'}]}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(1);
|
|
expect(MQTT.publish).toHaveBeenCalledWith('homeassistant/sensor/0x000b57fffec6a5b2/update_available/config', null, {qos: 1, retain: true}, expect.any(Function));
|
|
|
|
// Non-existing device but invalid payload -> clear
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/sensor/0x123/temperature/config', '1}3');
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(0);
|
|
|
|
// Existing device, device automation -> don't clear
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/device_automation/0x000b57fffec6a5b2/action_button_3_single/config', stringify({topic: 'zigbee2mqtt/0x000b57fffec6a5b2/availability'}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(0);
|
|
|
|
// Device automation of different instance -> don't clear
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/device_automation/0x000b57fffec6a5b2_not_existing/action_button_3_single/config', stringify({topic: 'zigbee2mqtt_different/0x000b57fffec6a5b2_not_existing/availability'}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledTimes(0);
|
|
|
|
// Device was flagged to be excluded from homeassistant discovery
|
|
settings.set(['devices', '0x000b57fffec6a5b2', 'homeassistant'], null);
|
|
await resetExtension();
|
|
MQTT.publish.mockClear();
|
|
|
|
await MQTT.events.message('homeassistant/sensor/0x000b57fffec6a5b2/update_available/config', stringify({availability: [{topic: 'zigbee2mqtt/bridge/state'}]}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledWith('homeassistant/sensor/0x000b57fffec6a5b2/update_available/config', null, {qos: 1, retain: true}, expect.any(Function));
|
|
MQTT.publish.mockClear();
|
|
await MQTT.events.message('homeassistant/device_automation/0x000b57fffec6a5b2/action_button_3_single/config', stringify({topic: 'zigbee2mqtt/0x000b57fffec6a5b2/availability'}));
|
|
await flushPromises();
|
|
expect(MQTT.publish).toHaveBeenCalledWith('homeassistant/device_automation/0x000b57fffec6a5b2/action_button_3_single/config', null, {qos: 1, retain: true}, expect.any(Function));
|
|
});
|
|
|
|
it('Should not have Home Assistant legacy entity attributes when disabled', async () => {
|
|
settings.set(['advanced', 'homeassistant_legacy_entity_attributes'], false);
|
|
await resetExtension();
|
|
|
|
let payload;
|
|
await flushPromises();
|
|
|
|
payload = {
|
|
'unit_of_measurement': '°C',
|
|
'device_class': 'temperature',
|
|
'state_class': 'measurement',
|
|
'value_template': '{{ value_json.temperature }}',
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'object_id': 'weather_sensor_temperature',
|
|
'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
|
|
'origin': origin,
|
|
'enabled_by_default': true,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should rediscover group when device is added to it', async () => {
|
|
MQTT.publish.mockClear();
|
|
MQTT.events.message('zigbee2mqtt/bridge/request/group/members/add', stringify({group: 'ha_discovery_group', device: 'wall_switch_double/left'}));
|
|
await flushPromises();
|
|
|
|
const payload = {
|
|
"availability":[{"topic":"zigbee2mqtt/bridge/state"}],
|
|
"brightness":true,
|
|
"brightness_scale":254,
|
|
"color_mode":true,
|
|
"command_topic":"zigbee2mqtt/ha_discovery_group/set",
|
|
"device":{
|
|
"identifiers":["zigbee2mqtt_1221051039810110150109113116116_9"],
|
|
"name":"ha_discovery_group",
|
|
"sw_version": version,
|
|
},
|
|
"json_attributes_topic":"zigbee2mqtt/ha_discovery_group",
|
|
"max_mireds": 454,
|
|
"min_mireds": 250,
|
|
"name":null,
|
|
"schema":"json",
|
|
"state_topic":"zigbee2mqtt/ha_discovery_group",
|
|
"supported_color_modes":[
|
|
"xy",
|
|
"color_temp"
|
|
],
|
|
"effect":true,
|
|
"effect_list":[
|
|
"blink",
|
|
"breathe",
|
|
"okay",
|
|
"channel_change",
|
|
"candle",
|
|
"fireplace",
|
|
"colorloop",
|
|
"finish_effect",
|
|
"stop_effect",
|
|
"stop_hue_effect",
|
|
],
|
|
"object_id":"ha_discovery_group",
|
|
"unique_id":"9_light_zigbee2mqtt",
|
|
'origin': origin,
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/light/1221051039810110150109113116116_9/light/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover with json availability payload value_template', async () => {
|
|
settings.set(['advanced', 'legacy_availability_payload'], false);
|
|
await resetExtension();
|
|
|
|
const payload = {
|
|
"availability":[{"topic":"zigbee2mqtt/bridge/state","value_template":'{{ value_json.state }}'}],
|
|
"brightness":true,
|
|
"brightness_scale":254,
|
|
"color_mode":true,
|
|
"command_topic":"zigbee2mqtt/ha_discovery_group/set",
|
|
"device":{
|
|
"identifiers":["zigbee2mqtt_1221051039810110150109113116116_9"],
|
|
"name":"ha_discovery_group",
|
|
"sw_version": version,
|
|
},
|
|
"max_mireds": 454,
|
|
"min_mireds": 250,
|
|
"json_attributes_topic":"zigbee2mqtt/ha_discovery_group",
|
|
"name":null,
|
|
"schema":"json",
|
|
"state_topic":"zigbee2mqtt/ha_discovery_group",
|
|
"supported_color_modes":[
|
|
"xy",
|
|
"color_temp"
|
|
],
|
|
"effect":true,
|
|
"effect_list":[
|
|
"blink",
|
|
"breathe",
|
|
"okay",
|
|
"channel_change",
|
|
"candle",
|
|
"fireplace",
|
|
"colorloop",
|
|
"finish_effect",
|
|
"stop_effect",
|
|
"stop_hue_effect",
|
|
],
|
|
"object_id":"ha_discovery_group",
|
|
"unique_id":"9_light_zigbee2mqtt",
|
|
'origin': origin,
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/light/1221051039810110150109113116116_9/light/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover with availability offline when device is disabled', async () => {
|
|
settings.set(['devices', '0x000b57fffec6a5b2', 'disabled'], true);
|
|
|
|
await resetExtension();
|
|
|
|
const payload = {
|
|
"availability":[
|
|
{
|
|
"topic":"zigbee2mqtt/bridge/state",
|
|
"value_template": `{{ "offline" }}`,
|
|
}
|
|
],
|
|
"brightness":true,
|
|
"brightness_scale":254,
|
|
"color_mode":true,
|
|
"command_topic":"zigbee2mqtt/bulb/set",
|
|
"device":{
|
|
"identifiers":[
|
|
"zigbee2mqtt_0x000b57fffec6a5b2"
|
|
],
|
|
"manufacturer":"IKEA",
|
|
"model":"TRADFRI LED bulb E26/E27 980 lumen, dimmable, white spectrum, opal white (LED1545G12)",
|
|
"name":"bulb",
|
|
"sw_version":null
|
|
},
|
|
"effect":true,
|
|
"effect_list":[
|
|
"blink",
|
|
"breathe",
|
|
"okay",
|
|
"channel_change",
|
|
"finish_effect",
|
|
"stop_effect"
|
|
],
|
|
"json_attributes_topic":"zigbee2mqtt/bulb",
|
|
"max_mireds":454,
|
|
"min_mireds":250,
|
|
"name":null,
|
|
"schema":"json",
|
|
"state_topic":"zigbee2mqtt/bulb",
|
|
"supported_color_modes":[
|
|
"color_temp"
|
|
],
|
|
"object_id":"bulb",
|
|
"unique_id":"0x000b57fffec6a5b2_light_zigbee2mqtt",
|
|
'origin': origin,
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/light/0x000b57fffec6a5b2/light/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover last_seen when enabled', async () => {
|
|
settings.set(['advanced', 'last_seen'], 'ISO_8601');
|
|
await resetExtension();
|
|
|
|
const payload = {
|
|
"availability":[
|
|
{
|
|
"topic":"zigbee2mqtt/bridge/state"
|
|
}
|
|
],
|
|
"device":{
|
|
"identifiers":[
|
|
"zigbee2mqtt_0x000b57fffec6a5b2"
|
|
],
|
|
"manufacturer":"IKEA",
|
|
"model":"TRADFRI LED bulb E26/E27 980 lumen, dimmable, white spectrum, opal white (LED1545G12)",
|
|
"name":"bulb",
|
|
"sw_version": null
|
|
},
|
|
"enabled_by_default":false,
|
|
"icon":"mdi:clock",
|
|
"json_attributes_topic":"zigbee2mqtt/bulb",
|
|
"name":"Last seen",
|
|
"state_topic":"zigbee2mqtt/bulb",
|
|
"object_id": "bulb_last_seen",
|
|
"unique_id":"0x000b57fffec6a5b2_last_seen_zigbee2mqtt",
|
|
'origin': origin,
|
|
"value_template":"{{ value_json.last_seen }}",
|
|
"device_class": "timestamp",
|
|
"entity_category": "diagnostic"
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x000b57fffec6a5b2/last_seen/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
|
|
it('Should discover devices with configuration url', async () => {
|
|
settings.set(['frontend', 'url'], 'http://zigbee.mqtt');
|
|
|
|
await resetExtension();
|
|
|
|
let payload;
|
|
await flushPromises();
|
|
|
|
payload = {
|
|
'unit_of_measurement': '°C',
|
|
'device_class': 'temperature',
|
|
'state_class': 'measurement',
|
|
'enabled_by_default': true,
|
|
'value_template': "{{ value_json.temperature }}",
|
|
'state_topic': 'zigbee2mqtt/weather_sensor',
|
|
'json_attributes_topic': 'zigbee2mqtt/weather_sensor',
|
|
'object_id': 'weather_sensor_temperature',
|
|
'unique_id': '0x0017880104e45522_temperature_zigbee2mqtt',
|
|
'origin': origin,
|
|
'device': {
|
|
'identifiers': ['zigbee2mqtt_0x0017880104e45522'],
|
|
'name': 'weather_sensor',
|
|
'sw_version': null,
|
|
'model': 'Aqara temperature, humidity and pressure sensor (WSDCGQ11LM)',
|
|
'manufacturer': 'Xiaomi',
|
|
'configuration_url': 'http://zigbee.mqtt/#/device/0x0017880104e45522/info'
|
|
},
|
|
'availability': [{topic: 'zigbee2mqtt/bridge/state'}],
|
|
};
|
|
|
|
expect(MQTT.publish).toHaveBeenCalledWith(
|
|
'homeassistant/sensor/0x0017880104e45522/temperature/config',
|
|
stringify(payload),
|
|
{ retain: true, qos: 1 },
|
|
expect.any(Function),
|
|
);
|
|
});
|
|
});
|