def _logbook_filtering(hass, last_changed, last_updated): from homeassistant.components import logbook entity_id = 'test.entity' old_state = {'entity_id': entity_id, 'state': 'off'} new_state = { 'entity_id': entity_id, 'state': 'on', 'last_updated': last_updated, 'last_changed': last_changed } event = core.Event(EVENT_STATE_CHANGED, { 'entity_id': entity_id, 'old_state': old_state, 'new_state': new_state }) def yield_events(event): # pylint: disable=protected-access entities_filter = logbook._generate_filter_from_config({}) for _ in range(10**5): if logbook._keep_event(event, entities_filter): yield event start = timer() list(logbook.humanify(None, yield_events(event))) return timer() - start
async def _logbook_filtering(hass, last_changed, last_updated): # pylint: disable=import-outside-toplevel from homeassistant.components import logbook entity_id = "test.entity" old_state = {"entity_id": entity_id, "state": "off"} new_state = { "entity_id": entity_id, "state": "on", "last_updated": last_updated, "last_changed": last_changed, } event = _create_state_changed_event_from_old_new(entity_id, dt_util.utcnow(), old_state, new_state) entity_attr_cache = logbook.EntityAttributeCache(hass) entities_filter = convert_include_exclude_filter( logbook.INCLUDE_EXCLUDE_BASE_FILTER_SCHEMA({})) def yield_events(event): for _ in range(10**5): # pylint: disable=protected-access if logbook._keep_event(hass, event, entities_filter): yield event start = timer() list(logbook.humanify(hass, yield_events(event), entity_attr_cache, {})) return timer() - start
async def test_logbook_humanify_script_started_event(hass): """Test humanifying script started event.""" hass.config.components.add("recorder") await async_setup_component(hass, DOMAIN, {}) await async_setup_component(hass, "logbook", {}) entity_attr_cache = logbook.EntityAttributeCache(hass) event1, event2 = list( logbook.humanify( hass, [ MockLazyEventPartialState( EVENT_SCRIPT_STARTED, {ATTR_ENTITY_ID: "script.hello", ATTR_NAME: "Hello Script"}, ), MockLazyEventPartialState( EVENT_SCRIPT_STARTED, {ATTR_ENTITY_ID: "script.bye", ATTR_NAME: "Bye Script"}, ), ], entity_attr_cache, {}, ) ) assert event1["name"] == "Hello Script" assert event1["domain"] == "script" assert event1["message"] == "started" assert event1["entity_id"] == "script.hello" assert event2["name"] == "Bye Script" assert event2["domain"] == "script" assert event2["message"] == "started" assert event2["entity_id"] == "script.bye"
def _logbook_filtering(hass, last_changed, last_updated): from homeassistant.components import logbook entity_id = 'test.entity' old_state = {'entity_id': entity_id, 'state': 'off'} new_state = { 'entity_id': entity_id, 'state': 'on', 'last_updated': last_updated, 'last_changed': last_changed } event = core.Event(EVENT_STATE_CHANGED, { 'entity_id': entity_id, 'old_state': old_state, 'new_state': new_state }) events = [event] * 10**5 start = timer() # pylint: disable=protected-access events = logbook._exclude_events(events, {}) list(logbook.humanify(events)) return timer() - start
def test_humanify_filter_sensor(self): """ Test humanify filter too frequent sensor values. """ entity_id = 'sensor.bla' pointA = dt_util.strip_microseconds(dt_util.utcnow().replace(minute=2)) pointB = pointA.replace(minute=5) pointC = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointB, entity_id, 20) eventC = self.create_state_changed_event(pointC, entity_id, 30) entries = list(logbook.humanify((eventA, eventB, eventC))) self.assertEqual(2, len(entries)) self.assert_entry(entries[0], pointB, 'bla', domain='sensor', entity_id=entity_id) self.assert_entry(entries[1], pointC, 'bla', domain='sensor', entity_id=entity_id)
async def test_humanify_homekit_changed_event(hass): """Test humanifying HomeKit changed event.""" event1, event2 = list( logbook.humanify(hass, [ ha.Event( EVENT_HOMEKIT_CHANGED, { ATTR_ENTITY_ID: 'lock.front_door', ATTR_DISPLAY_NAME: 'Front Door', ATTR_SERVICE: 'lock', }), ha.Event( EVENT_HOMEKIT_CHANGED, { ATTR_ENTITY_ID: 'cover.window', ATTR_DISPLAY_NAME: 'Window', ATTR_SERVICE: 'set_cover_position', ATTR_VALUE: 75, }), ])) assert event1['name'] == 'HomeKit' assert event1['domain'] == DOMAIN_HOMEKIT assert event1['message'] == 'send command lock for Front Door' assert event1['entity_id'] == 'lock.front_door' assert event2['name'] == 'HomeKit' assert event2['domain'] == DOMAIN_HOMEKIT assert event2['message'] == \ 'send command set_cover_position to 75 for Window' assert event2['entity_id'] == 'cover.window'
def test_exclude_events_domain(self): """Test if events are filtered if domain is excluded in config.""" entity_id = 'switch.bla' entity_id2 = 'sensor.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointB, entity_id2, 20) config = logbook.CONFIG_SCHEMA({ ha.DOMAIN: {}, logbook.DOMAIN: { logbook.CONF_EXCLUDE: { logbook.CONF_DOMAINS: ['switch', 'alexa', DOMAIN_HOMEKIT] } } }) events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_START), ha.Event(EVENT_ALEXA_SMART_HOME), ha.Event(EVENT_HOMEKIT_CHANGED), eventA, eventB), logbook._generate_filter_from_config(config[logbook.DOMAIN])) entries = list(logbook.humanify(self.hass, events)) assert 2 == len(entries) self.assert_entry(entries[0], name='Home Assistant', message='started', domain=ha.DOMAIN) self.assert_entry(entries[1], pointB, 'blu', domain='sensor', entity_id=entity_id2)
def test_exclude_events_entity(self): """Test if events are filtered if entity is excluded in config.""" entity_id = 'sensor.bla' entity_id2 = 'sensor.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointB, entity_id2, 20) config = logbook.CONFIG_SCHEMA({ ha.DOMAIN: {}, logbook.DOMAIN: {logbook.CONF_EXCLUDE: { logbook.CONF_ENTITIES: [entity_id, ]}}}) events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_STOP), eventA, eventB), config[logbook.DOMAIN]) entries = list(logbook.humanify(events)) self.assertEqual(2, len(entries)) self.assert_entry( entries[0], name='Home Assistant', message='stopped', domain=ha.DOMAIN) self.assert_entry( entries[1], pointB, 'blu', domain='sensor', entity_id=entity_id2)
def _logbook_filtering(hass, last_changed, last_updated): from homeassistant.components import logbook entity_id = 'test.entity' old_state = { 'entity_id': entity_id, 'state': 'off' } new_state = { 'entity_id': entity_id, 'state': 'on', 'last_updated': last_updated, 'last_changed': last_changed } event = core.Event(EVENT_STATE_CHANGED, { 'entity_id': entity_id, 'old_state': old_state, 'new_state': new_state }) def yield_events(event): # pylint: disable=protected-access entities_filter = logbook._generate_filter_from_config({}) for _ in range(10**5): if logbook._keep_event(event, entities_filter): yield event start = timer() list(logbook.humanify(None, yield_events(event))) return timer() - start
def test_exclude_removed_entities(self): """Test if events are excluded on last update.""" entity_id = 'sensor.bla' entity_id2 = 'sensor.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointB, entity_id2, 20) eventA.data['new_state'] = None events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_STOP), eventA, eventB), {}) entries = list(logbook.humanify(events)) self.assertEqual(2, len(entries)) self.assert_entry(entries[0], name='Home Assistant', message='stopped', domain=ha.DOMAIN) self.assert_entry(entries[1], pointB, 'blu', domain='sensor', entity_id=entity_id2)
def test_exclude_script_events(self): """Test if script start can be excluded by entity_id.""" name = 'My Script Rule' domain = 'script' entity_id = 'script.my_script' entity_id2 = 'script.my_script_2' entity_id2 = 'sensor.blu' eventA = ha.Event(logbook.EVENT_SCRIPT_STARTED, { logbook.ATTR_NAME: name, logbook.ATTR_ENTITY_ID: entity_id, }) eventB = ha.Event(logbook.EVENT_SCRIPT_STARTED, { logbook.ATTR_NAME: name, logbook.ATTR_ENTITY_ID: entity_id2, }) config = logbook.CONFIG_SCHEMA({ ha.DOMAIN: {}, logbook.DOMAIN: {logbook.CONF_EXCLUDE: { logbook.CONF_ENTITIES: [entity_id, ]}}}) events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_STOP), eventA, eventB), logbook._generate_filter_from_config(config[logbook.DOMAIN])) entries = list(logbook.humanify(self.hass, events)) assert 2 == len(entries) self.assert_entry( entries[0], name='Home Assistant', message='stopped', domain=ha.DOMAIN) self.assert_entry( entries[1], name=name, domain=domain, entity_id=entity_id2)
def _logbook_filtering(hass, last_changed, last_updated): from homeassistant.components import logbook entity_id = 'test.entity' old_state = { 'entity_id': entity_id, 'state': 'off' } new_state = { 'entity_id': entity_id, 'state': 'on', 'last_updated': last_updated, 'last_changed': last_changed } event = core.Event(EVENT_STATE_CHANGED, { 'entity_id': entity_id, 'old_state': old_state, 'new_state': new_state }) events = [event] * 10**5 start = timer() # pylint: disable=protected-access events = logbook._exclude_events(events, {}) list(logbook.humanify(events)) return timer() - start
def test_exclude_events_domain(self): """Test if events are filtered if domain is excluded in config.""" entity_id = 'switch.bla' entity_id2 = 'sensor.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointB, entity_id2, 20) config = logbook.CONFIG_SCHEMA({ ha.DOMAIN: {}, logbook.DOMAIN: {logbook.CONF_EXCLUDE: { logbook.CONF_DOMAINS: ['switch', 'alexa', DOMAIN_HOMEKIT]}}}) events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_START), ha.Event(EVENT_ALEXA_SMART_HOME), ha.Event(EVENT_HOMEKIT_CHANGED), eventA, eventB), logbook._generate_filter_from_config(config[logbook.DOMAIN])) entries = list(logbook.humanify(self.hass, events)) assert 2 == len(entries) self.assert_entry(entries[0], name='Home Assistant', message='started', domain=ha.DOMAIN) self.assert_entry(entries[1], pointB, 'blu', domain='sensor', entity_id=entity_id2)
def test_home_assistant_start_stop_grouped(self): """ Tests if home assistant start and stop events are grouped if occuring in the same minute. """ entries = list(logbook.humanify((ha.Event(EVENT_HOMEASSISTANT_STOP), ha.Event(EVENT_HOMEASSISTANT_START)))) self.assertEqual(1, len(entries)) self.assert_entry(entries[0], name="Home Assistant", message="restarted", domain=ha.DOMAIN)
def test_exclude_events_hidden(self): """Test if events are excluded if entity is hidden.""" entity_id = 'sensor.bla' entity_id2 = 'sensor.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA = self.create_state_changed_event(pointA, entity_id, 10, {ATTR_HIDDEN: 'true'}) eventB = self.create_state_changed_event(pointB, entity_id2, 20) events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_STOP), eventA, eventB), logbook._generate_filter_from_config({})) entries = list(logbook.humanify(self.hass, events)) assert 2 == len(entries) self.assert_entry(entries[0], name='Home Assistant', message='stopped', domain=ha.DOMAIN) self.assert_entry(entries[1], pointB, 'blu', domain='sensor', entity_id=entity_id2)
def test_include_events_entity(self): """Test if events are filtered if entity is included in config.""" entity_id = 'sensor.bla' entity_id2 = 'sensor.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointB, entity_id2, 20) config = logbook.CONFIG_SCHEMA({ ha.DOMAIN: {}, logbook.DOMAIN: {logbook.CONF_INCLUDE: { logbook.CONF_ENTITIES: [entity_id2, ]}}}) events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_STOP), eventA, eventB), config[logbook.DOMAIN]) entries = list(logbook.humanify(self.hass, events)) self.assertEqual(2, len(entries)) self.assert_entry( entries[0], name='Home Assistant', message='stopped', domain=ha.DOMAIN) self.assert_entry( entries[1], pointB, 'blu', domain='sensor', entity_id=entity_id2)
def test_include_exclude_events(self): """Test if events are filtered if include and exclude is configured.""" entity_id = 'switch.bla' entity_id2 = 'sensor.blu' entity_id3 = 'sensor.bli' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA1 = self.create_state_changed_event(pointA, entity_id, 10) eventA2 = self.create_state_changed_event(pointA, entity_id2, 10) eventA3 = self.create_state_changed_event(pointA, entity_id3, 10) eventB1 = self.create_state_changed_event(pointB, entity_id, 20) eventB2 = self.create_state_changed_event(pointB, entity_id2, 20) config = logbook.CONFIG_SCHEMA({ ha.DOMAIN: {}, logbook.DOMAIN: { logbook.CONF_INCLUDE: { logbook.CONF_DOMAINS: ['sensor', ], logbook.CONF_ENTITIES: ['switch.bla', ]}, logbook.CONF_EXCLUDE: { logbook.CONF_DOMAINS: ['switch', ], logbook.CONF_ENTITIES: ['sensor.bli', ]}}}) events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_START), eventA1, eventA2, eventA3, eventB1, eventB2), config[logbook.DOMAIN]) entries = list(logbook.humanify(self.hass, events)) self.assertEqual(3, len(entries)) self.assert_entry(entries[0], name='Home Assistant', message='started', domain=ha.DOMAIN) self.assert_entry(entries[1], pointA, 'blu', domain='sensor', entity_id=entity_id2) self.assert_entry(entries[2], pointB, 'blu', domain='sensor', entity_id=entity_id2)
def test_exclude_automation_events(self): """Test if automation entries can be excluded by entity_id.""" name = 'My Automation Rule' domain = 'automation' entity_id = 'automation.my_automation_rule' entity_id2 = 'automation.my_automation_rule_2' entity_id2 = 'sensor.blu' eventA = ha.Event(logbook.EVENT_AUTOMATION_TRIGGERED, { logbook.ATTR_NAME: name, logbook.ATTR_ENTITY_ID: entity_id, }) eventB = ha.Event(logbook.EVENT_AUTOMATION_TRIGGERED, { logbook.ATTR_NAME: name, logbook.ATTR_ENTITY_ID: entity_id2, }) config = logbook.CONFIG_SCHEMA({ ha.DOMAIN: {}, logbook.DOMAIN: {logbook.CONF_EXCLUDE: { logbook.CONF_ENTITIES: [entity_id, ]}}}) entities_filter = logbook._generate_filter_from_config( config[logbook.DOMAIN]) events = [e for e in (ha.Event(EVENT_HOMEASSISTANT_STOP), eventA, eventB) if logbook._keep_event(e, entities_filter)] entries = list(logbook.humanify(self.hass, events)) assert 2 == len(entries) self.assert_entry( entries[0], name='Home Assistant', message='stopped', domain=ha.DOMAIN) self.assert_entry( entries[1], name=name, domain=domain, entity_id=entity_id2)
async def test_humanify_homekit_changed_event(hass): """Test humanifying HomeKit changed event.""" event1, event2 = list(logbook.humanify(hass, [ ha.Event(EVENT_HOMEKIT_CHANGED, { ATTR_ENTITY_ID: 'lock.front_door', ATTR_DISPLAY_NAME: 'Front Door', ATTR_SERVICE: 'lock', }), ha.Event(EVENT_HOMEKIT_CHANGED, { ATTR_ENTITY_ID: 'cover.window', ATTR_DISPLAY_NAME: 'Window', ATTR_SERVICE: 'set_cover_position', ATTR_VALUE: 75, }), ])) assert event1['name'] == 'HomeKit' assert event1['domain'] == DOMAIN_HOMEKIT assert event1['message'] == 'send command lock for Front Door' assert event1['entity_id'] == 'lock.front_door' assert event2['name'] == 'HomeKit' assert event1['domain'] == DOMAIN_HOMEKIT assert event2['message'] == \ 'send command set_cover_position to 75 for Window' assert event2['entity_id'] == 'cover.window'
async def test_humanify_alexa_event(hass): """Test humanifying Alexa event.""" await async_setup_component(hass, "alexa", {}) hass.states.async_set("light.kitchen", "on", {"friendly_name": "Kitchen Light"}) results = list( logbook.humanify( hass, [ ha.Event( EVENT_ALEXA_SMART_HOME, { "request": { "namespace": "Alexa.Discovery", "name": "Discover" } }, ), ha.Event( EVENT_ALEXA_SMART_HOME, { "request": { "namespace": "Alexa.PowerController", "name": "TurnOn", "entity_id": "light.kitchen", } }, ), ha.Event( EVENT_ALEXA_SMART_HOME, { "request": { "namespace": "Alexa.PowerController", "name": "TurnOn", "entity_id": "light.non_existing", } }, ), ], )) event1, event2, event3 = results assert event1["name"] == "Amazon Alexa" assert event1["message"] == "send command Alexa.Discovery/Discover" assert event1["entity_id"] is None assert event2["name"] == "Amazon Alexa" assert (event2["message"] == "send command Alexa.PowerController/TurnOn for Kitchen Light") assert event2["entity_id"] == "light.kitchen" assert event3["name"] == "Amazon Alexa" assert (event3["message"] == "send command Alexa.PowerController/TurnOn for light.non_existing") assert event3["entity_id"] == "light.non_existing"
def test_filter_continuous_sensor_values(self): """Test remove continuous sensor events from logbook.""" entity_id = "sensor.bla" pointA = dt_util.utcnow() attributes = {"unit_of_measurement": "foo"} eventA = self.create_state_changed_event(pointA, entity_id, 10, attributes) entries = list(logbook.humanify((eventA,))) self.assertEqual(0, len(entries))
def test_include_exclude_events(self): """Test if events are filtered if include and exclude is configured.""" entity_id = 'switch.bla' entity_id2 = 'sensor.blu' entity_id3 = 'sensor.bli' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA1 = self.create_state_changed_event(pointA, entity_id, 10) eventA2 = self.create_state_changed_event(pointA, entity_id2, 10) eventA3 = self.create_state_changed_event(pointA, entity_id3, 10) eventB1 = self.create_state_changed_event(pointB, entity_id, 20) eventB2 = self.create_state_changed_event(pointB, entity_id2, 20) config = logbook.CONFIG_SCHEMA({ ha.DOMAIN: {}, logbook.DOMAIN: { logbook.CONF_INCLUDE: { logbook.CONF_DOMAINS: [ 'sensor', ], logbook.CONF_ENTITIES: [ 'switch.bla', ] }, logbook.CONF_EXCLUDE: { logbook.CONF_DOMAINS: [ 'switch', ], logbook.CONF_ENTITIES: [ 'sensor.bli', ] } } }) events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_START), eventA1, eventA2, eventA3, eventB1, eventB2), config[logbook.DOMAIN]) entries = list(logbook.humanify(events)) self.assertEqual(3, len(entries)) self.assert_entry(entries[0], name='Home Assistant', message='started', domain=ha.DOMAIN) self.assert_entry(entries[1], pointA, 'blu', domain='sensor', entity_id=entity_id2) self.assert_entry(entries[2], pointB, 'blu', domain='sensor', entity_id=entity_id2)
def test_filter_continuous_sensor_values(self): """Test remove continuous sensor events from logbook.""" entity_id = 'sensor.bla' pointA = dt_util.utcnow() attributes = {'unit_of_measurement': 'foo'} eventA = self.create_state_changed_event( pointA, entity_id, 10, attributes) entries = list(logbook.humanify(self.hass, (eventA,))) assert 0 == len(entries)
def test_filter_continuous_sensor_values(self): """Test remove continuous sensor events from logbook.""" entity_id = 'sensor.bla' pointA = dt_util.utcnow() attributes = {'unit_of_measurement': 'foo'} eventA = self.create_state_changed_event(pointA, entity_id, 10, attributes) entries = list(logbook.humanify((eventA, ))) self.assertEqual(0, len(entries))
def test_home_assistant_start_stop_grouped(self): """ Tests if home assistant start and stop events are grouped if occuring in the same minute. """ entries = list( logbook.humanify(( ha.Event(EVENT_HOMEASSISTANT_STOP), ha.Event(EVENT_HOMEASSISTANT_START), ))) self.assertEqual(1, len(entries)) self.assert_entry(entries[0], name='Home Assistant', message='restarted', domain=ha.DOMAIN)
def test_home_assistant_start_stop_grouped(self): """Test if HA start and stop events are grouped. Events that are occurring in the same minute. """ entries = list(logbook.humanify(self.hass, ( ha.Event(EVENT_HOMEASSISTANT_STOP), ha.Event(EVENT_HOMEASSISTANT_START), ))) self.assertEqual(1, len(entries)) self.assert_entry( entries[0], name='Home Assistant', message='restarted', domain=ha.DOMAIN)
def test_home_assistant_start_stop_grouped(self): """Test if HA start and stop events are grouped. Events that are occurring in the same minute. """ entries = list(logbook.humanify(self.hass, ( ha.Event(EVENT_HOMEASSISTANT_STOP), ha.Event(EVENT_HOMEASSISTANT_START), ))) assert 1 == len(entries) self.assert_entry( entries[0], name='Home Assistant', message='restarted', domain=ha.DOMAIN)
def test_include_events_domain(self): """Test if events are filtered if domain is included in config.""" entity_id = 'switch.bla' entity_id2 = 'sensor.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) event_alexa = ha.Event(EVENT_ALEXA_SMART_HOME, { 'request': { 'namespace': 'Alexa.Discovery', 'name': 'Discover', } }) event_homekit = ha.Event( EVENT_HOMEKIT_CHANGED, { ATTR_ENTITY_ID: 'lock.front_door', ATTR_DISPLAY_NAME: 'Front Door', ATTR_SERVICE: 'lock', }) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointB, entity_id2, 20) config = logbook.CONFIG_SCHEMA({ ha.DOMAIN: {}, logbook.DOMAIN: { logbook.CONF_INCLUDE: { logbook.CONF_DOMAINS: ['sensor', 'alexa', DOMAIN_HOMEKIT] } } }) events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_START), event_alexa, event_homekit, eventA, eventB), logbook._generate_filter_from_config(config[logbook.DOMAIN])) entries = list(logbook.humanify(self.hass, events)) assert 4 == len(entries) self.assert_entry(entries[0], name='Home Assistant', message='started', domain=ha.DOMAIN) self.assert_entry(entries[1], name='Amazon Alexa', domain='alexa') self.assert_entry(entries[2], name='HomeKit', domain=DOMAIN_HOMEKIT) self.assert_entry(entries[3], pointB, 'blu', domain='sensor', entity_id=entity_id2)
def test_exclude_auto_groups(self): """Test if events of automatically generated groups are filtered.""" entity_id = 'switch.bla' entity_id2 = 'group.switches' pointA = dt_util.utcnow() eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointA, entity_id2, 20, {'auto': True}) entries = list(logbook.humanify((eventA, eventB))) self.assertEqual(1, len(entries)) self.assert_entry(entries[0], pointA, 'bla', domain='switch', entity_id=entity_id)
def test_exclude_auto_groups(self): """Test if events of automatically generated groups are filtered.""" entity_id = 'switch.bla' entity_id2 = 'group.switches' pointA = dt_util.utcnow() eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointA, entity_id2, 20, {'auto': True}) entries = list(logbook.humanify((eventA, eventB))) self.assertEqual(1, len(entries)) self.assert_entry(entries[0], pointA, 'bla', domain='switch', entity_id=entity_id)
async def test_humanify_shelly_click_event_block_device(hass, coap_wrapper): """Test humanifying Shelly click event for block device.""" assert coap_wrapper hass.config.components.add("recorder") assert await async_setup_component(hass, "logbook", {}) entity_attr_cache = logbook.EntityAttributeCache(hass) event1, event2 = list( logbook.humanify( hass, [ MockLazyEventPartialState( EVENT_SHELLY_CLICK, { ATTR_DEVICE_ID: coap_wrapper.device_id, ATTR_DEVICE: "shellyix3-12345678", ATTR_CLICK_TYPE: "single", ATTR_CHANNEL: 1, }, ), MockLazyEventPartialState( EVENT_SHELLY_CLICK, { ATTR_DEVICE_ID: "no_device_id", ATTR_DEVICE: "shellyswitch25-12345678", ATTR_CLICK_TYPE: "long", ATTR_CHANNEL: 2, }, ), ], entity_attr_cache, {}, ) ) assert event1["name"] == "Shelly" assert event1["domain"] == DOMAIN assert ( event1["message"] == "'single' click event for Test name channel 1 Input was fired." ) assert event2["name"] == "Shelly" assert event2["domain"] == DOMAIN assert ( event2["message"] == "'long' click event for shellyswitch25-12345678 channel 2 Input was fired." )
async def test_humanify_shelly_click_event_rpc_device(hass, rpc_wrapper): """Test humanifying Shelly click event for rpc device.""" assert rpc_wrapper hass.config.components.add("recorder") assert await async_setup_component(hass, "logbook", {}) entity_attr_cache = logbook.EntityAttributeCache(hass) event1, event2 = list( logbook.humanify( hass, [ MockLazyEventPartialState( EVENT_SHELLY_CLICK, { ATTR_DEVICE_ID: rpc_wrapper.device_id, ATTR_DEVICE: "shellyplus1pm-12345678", ATTR_CLICK_TYPE: "single_push", ATTR_CHANNEL: 1, }, ), MockLazyEventPartialState( EVENT_SHELLY_CLICK, { ATTR_DEVICE_ID: "no_device_id", ATTR_DEVICE: "shellypro4pm-12345678", ATTR_CLICK_TYPE: "btn_down", ATTR_CHANNEL: 2, }, ), ], entity_attr_cache, {}, ) ) assert event1["name"] == "Shelly" assert event1["domain"] == DOMAIN assert ( event1["message"] == "'single_push' click event for test switch_0 Input was fired." ) assert event2["name"] == "Shelly" assert event2["domain"] == DOMAIN assert ( event2["message"] == "'btn_down' click event for shellypro4pm-12345678 channel 2 Input was fired." )
def test_exclude_automation_events(self): """Test if automation entries can be excluded by entity_id.""" name = 'My Automation Rule' message = 'has been triggered' domain = 'automation' entity_id = 'automation.my_automation_rule' entity_id2 = 'automation.my_automation_rule_2' entity_id2 = 'sensor.blu' eventA = ha.Event( logbook.EVENT_LOGBOOK_ENTRY, { logbook.ATTR_NAME: name, logbook.ATTR_MESSAGE: message, logbook.ATTR_DOMAIN: domain, logbook.ATTR_ENTITY_ID: entity_id, }) eventB = ha.Event( logbook.EVENT_LOGBOOK_ENTRY, { logbook.ATTR_NAME: name, logbook.ATTR_MESSAGE: message, logbook.ATTR_DOMAIN: domain, logbook.ATTR_ENTITY_ID: entity_id2, }) config = logbook.CONFIG_SCHEMA({ ha.DOMAIN: {}, logbook.DOMAIN: { logbook.CONF_EXCLUDE: { logbook.CONF_ENTITIES: [ entity_id, ] } } }) events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_STOP), eventA, eventB), config[logbook.DOMAIN]) entries = list(logbook.humanify(events)) self.assertEqual(2, len(entries)) self.assert_entry(entries[0], name='Home Assistant', message='stopped', domain=ha.DOMAIN) self.assert_entry(entries[1], name=name, domain=domain, entity_id=entity_id2)
def test_exclude_attribute_changes(self): """Test if events of attribute changes are filtered.""" entity_id = 'switch.bla' entity_id2 = 'switch.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=1) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event( pointA, entity_id2, 20, last_changed=pointA, last_updated=pointB) entries = list(logbook.humanify((eventA, eventB))) self.assertEqual(1, len(entries)) self.assert_entry(entries[0], pointA, 'bla', domain='switch', entity_id=entity_id)
def test_home_assistant_start(self): """Test if HA start is not filtered or converted into a restart.""" entity_id = 'switch.bla' pointA = dt_util.utcnow() entries = list(logbook.humanify(self.hass, ( ha.Event(EVENT_HOMEASSISTANT_START), self.create_state_changed_event(pointA, entity_id, 10) ))) self.assertEqual(2, len(entries)) self.assert_entry( entries[0], name='Home Assistant', message='started', domain=ha.DOMAIN) self.assert_entry(entries[1], pointA, 'bla', domain='switch', entity_id=entity_id)
def test_home_assistant_start(self): """Test if HA start is not filtered or converted into a restart.""" entity_id = 'switch.bla' pointA = dt_util.utcnow() entries = list(logbook.humanify(self.hass, ( ha.Event(EVENT_HOMEASSISTANT_START), self.create_state_changed_event(pointA, entity_id, 10) ))) self.assertEqual(2, len(entries)) self.assert_entry( entries[0], name='Home Assistant', message='started', domain=ha.DOMAIN) self.assert_entry(entries[1], pointA, 'bla', domain='switch', entity_id=entity_id)
def test_exclude_attribute_changes(self): """Test if events of attribute changes are filtered.""" entity_id = 'switch.bla' entity_id2 = 'switch.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=1) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event( pointA, entity_id2, 20, last_changed=pointA, last_updated=pointB) entries = list(logbook.humanify((eventA, eventB))) self.assertEqual(1, len(entries)) self.assert_entry(entries[0], pointA, 'bla', domain='switch', entity_id=entity_id)
async def test_humanify_alexa_event(hass): """Test humanifying Alexa event.""" hass.states.async_set('light.kitchen', 'on', {'friendly_name': 'Kitchen Light'}) results = list( logbook.humanify(hass, [ ha.Event(EVENT_ALEXA_SMART_HOME, { 'request': { 'namespace': 'Alexa.Discovery', 'name': 'Discover', } }), ha.Event( EVENT_ALEXA_SMART_HOME, { 'request': { 'namespace': 'Alexa.PowerController', 'name': 'TurnOn', 'entity_id': 'light.kitchen' } }), ha.Event( EVENT_ALEXA_SMART_HOME, { 'request': { 'namespace': 'Alexa.PowerController', 'name': 'TurnOn', 'entity_id': 'light.non_existing' } }), ])) event1, event2, event3 = results assert event1['name'] == 'Amazon Alexa' assert event1['message'] == 'send command Alexa.Discovery/Discover' assert event1['entity_id'] is None assert event2['name'] == 'Amazon Alexa' assert event2['message'] == \ 'send command Alexa.PowerController/TurnOn for Kitchen Light' assert event2['entity_id'] == 'light.kitchen' assert event3['name'] == 'Amazon Alexa' assert event3['message'] == \ 'send command Alexa.PowerController/TurnOn for light.non_existing' assert event3['entity_id'] == 'light.non_existing'
async def test_humanify_automation_trigger_event(hass): """Test humanifying Shelly click event.""" hass.config.components.add("recorder") assert await async_setup_component(hass, "automation", {}) assert await async_setup_component(hass, "logbook", {}) entity_attr_cache = logbook.EntityAttributeCache(hass) context = Context() event1, event2 = list( logbook.humanify( hass, [ MockLazyEventPartialState( automation.EVENT_AUTOMATION_TRIGGERED, { "name": "Bla", "entity_id": "automation.bla", "source": "state change of input_boolean.yo", }, context=context, ), MockLazyEventPartialState( automation.EVENT_AUTOMATION_TRIGGERED, { "name": "Bla", "entity_id": "automation.bla", }, context=context, ), ], entity_attr_cache, {}, )) assert event1["name"] == "Bla" assert event1[ "message"] == "has been triggered by state change of input_boolean.yo" assert event1["source"] == "state change of input_boolean.yo" assert event1["context_id"] == context.id assert event1["entity_id"] == "automation.bla" assert event2["name"] == "Bla" assert event2["message"] == "has been triggered" assert event2["source"] is None assert event2["context_id"] == context.id assert event2["entity_id"] == "automation.bla"
async def test_humanify_homekit_changed_event(hass, hk_driver, mock_get_source_ip): """Test humanifying HomeKit changed event.""" hass.config.components.add("recorder") with patch("homeassistant.components.homekit.HomeKit"): assert await async_setup_component(hass, "homekit", {"homekit": {}}) assert await async_setup_component(hass, "logbook", {}) entity_attr_cache = logbook.EntityAttributeCache(hass) event1, event2 = list( logbook.humanify( hass, [ MockLazyEventPartialState( EVENT_HOMEKIT_CHANGED, { ATTR_ENTITY_ID: "lock.front_door", ATTR_DISPLAY_NAME: "Front Door", ATTR_SERVICE: "lock", }, ), MockLazyEventPartialState( EVENT_HOMEKIT_CHANGED, { ATTR_ENTITY_ID: "cover.window", ATTR_DISPLAY_NAME: "Window", ATTR_SERVICE: "set_cover_position", ATTR_VALUE: 75, }, ), ], entity_attr_cache, {}, )) assert event1["name"] == "HomeKit" assert event1["domain"] == DOMAIN_HOMEKIT assert event1["message"] == "send command lock for Front Door" assert event1["entity_id"] == "lock.front_door" assert event2["name"] == "HomeKit" assert event2["domain"] == DOMAIN_HOMEKIT assert event2[ "message"] == "send command set_cover_position to 75 for Window" assert event2["entity_id"] == "cover.window"
def test_process_custom_logbook_entries(self): """Test if custom log book entries get added as an entry.""" name = 'Nice name' message = 'has a custom entry' entity_id = 'sun.sun' entries = list(logbook.humanify(self.hass, ( ha.Event(logbook.EVENT_LOGBOOK_ENTRY, { logbook.ATTR_NAME: name, logbook.ATTR_MESSAGE: message, logbook.ATTR_ENTITY_ID: entity_id, }), ))) self.assertEqual(1, len(entries)) self.assert_entry( entries[0], name=name, message=message, domain='sun', entity_id=entity_id)
def test_humanify_filter_sensor(self): """Test humanify filter too frequent sensor values.""" entity_id = "sensor.bla" pointA = dt_util.utcnow().replace(minute=2) pointB = pointA.replace(minute=5) pointC = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointB, entity_id, 20) eventC = self.create_state_changed_event(pointC, entity_id, 30) entries = list(logbook.humanify((eventA, eventB, eventC))) self.assertEqual(2, len(entries)) self.assert_entry(entries[0], pointB, "bla", domain="sensor", entity_id=entity_id) self.assert_entry(entries[1], pointC, "bla", domain="sensor", entity_id=entity_id)
def test_process_custom_logbook_entries(self): """Test if custom log book entries get added as an entry.""" name = 'Nice name' message = 'has a custom entry' entity_id = 'sun.sun' entries = list(logbook.humanify(self.hass, ( ha.Event(logbook.EVENT_LOGBOOK_ENTRY, { logbook.ATTR_NAME: name, logbook.ATTR_MESSAGE: message, logbook.ATTR_ENTITY_ID: entity_id, }), ))) self.assertEqual(1, len(entries)) self.assert_entry( entries[0], name=name, message=message, domain='sun', entity_id=entity_id)
def test_exclude_auto_groups(self): """Test if events of automatically generated groups are filtered.""" entity_id = 'switch.bla' entity_id2 = 'group.switches' pointA = dt_util.utcnow() eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointA, entity_id2, 20, {'auto': True}) entities_filter = logbook._generate_filter_from_config({}) events = [e for e in (eventA, eventB) if logbook._keep_event(e, entities_filter)] entries = list(logbook.humanify(self.hass, events)) assert 1 == len(entries) self.assert_entry(entries[0], pointA, 'bla', domain='switch', entity_id=entity_id)
def test_exclude_attribute_changes(self): """Test if events of attribute changes are filtered.""" entity_id = 'switch.bla' entity_id2 = 'switch.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=1) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event( pointA, entity_id2, 20, last_changed=pointA, last_updated=pointB) entities_filter = logbook._generate_filter_from_config({}) events = [e for e in (eventA, eventB) if logbook._keep_event(e, entities_filter)] entries = list(logbook.humanify(self.hass, events)) assert 1 == len(entries) self.assert_entry(entries[0], pointA, 'bla', domain='switch', entity_id=entity_id)
def test_exclude_removed_entities(self): """Test if events are excluded on last update.""" entity_id = 'sensor.bla' entity_id2 = 'sensor.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointB, entity_id2, 20) eventA.data['new_state'] = None events = logbook._exclude_events((ha.Event(EVENT_HOMEASSISTANT_STOP), eventA, eventB), self.EMPTY_CONFIG) entries = list(logbook.humanify(events)) self.assertEqual(2, len(entries)) self.assert_entry( entries[0], name='Home Assistant', message='stopped', domain=ha.DOMAIN) self.assert_entry( entries[1], pointB, 'blu', domain='sensor', entity_id=entity_id2)
def test_exclude_events_hidden(self): """Test if events are excluded if entity is hidden.""" entity_id = 'sensor.bla' entity_id2 = 'sensor.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA = self.create_state_changed_event(pointA, entity_id, 10, {ATTR_HIDDEN: 'true'}) eventB = self.create_state_changed_event(pointB, entity_id2, 20) events = logbook._exclude_events((ha.Event(EVENT_HOMEASSISTANT_STOP), eventA, eventB), {}) entries = list(logbook.humanify(self.hass, events)) self.assertEqual(2, len(entries)) self.assert_entry( entries[0], name='Home Assistant', message='stopped', domain=ha.DOMAIN) self.assert_entry( entries[1], pointB, 'blu', domain='sensor', entity_id=entity_id2)
async def test_logbook_humanify_automation_triggered_event(hass): """Test humanifying Automation Trigger event.""" hass.config.components.add("recorder") await async_setup_component(hass, automation.DOMAIN, {}) await async_setup_component(hass, "logbook", {}) entity_attr_cache = logbook.EntityAttributeCache(hass) event1, event2 = list( logbook.humanify( hass, [ MockLazyEventPartialState( EVENT_AUTOMATION_TRIGGERED, { ATTR_ENTITY_ID: "automation.hello", ATTR_NAME: "Hello Automation" }, ), MockLazyEventPartialState( EVENT_AUTOMATION_TRIGGERED, { ATTR_ENTITY_ID: "automation.bye", ATTR_NAME: "Bye Automation", ATTR_SOURCE: "source of trigger", }, ), ], entity_attr_cache, {}, )) assert event1["name"] == "Hello Automation" assert event1["domain"] == "automation" assert event1["message"] == "has been triggered" assert event1["entity_id"] == "automation.hello" assert event2["name"] == "Bye Automation" assert event2["domain"] == "automation" assert event2["message"] == "has been triggered by source of trigger" assert event2["entity_id"] == "automation.bye"
async def test_humanify_alexa_event(hass): """Test humanifying Alexa event.""" hass.states.async_set('light.kitchen', 'on', { 'friendly_name': 'Kitchen Light' }) results = list(logbook.humanify(hass, [ ha.Event(EVENT_ALEXA_SMART_HOME, {'request': { 'namespace': 'Alexa.Discovery', 'name': 'Discover', }}), ha.Event(EVENT_ALEXA_SMART_HOME, {'request': { 'namespace': 'Alexa.PowerController', 'name': 'TurnOn', 'entity_id': 'light.kitchen' }}), ha.Event(EVENT_ALEXA_SMART_HOME, {'request': { 'namespace': 'Alexa.PowerController', 'name': 'TurnOn', 'entity_id': 'light.non_existing' }}), ])) event1, event2, event3 = results assert event1['name'] == 'Amazon Alexa' assert event1['message'] == 'send command Alexa.Discovery/Discover' assert event1['entity_id'] is None assert event2['name'] == 'Amazon Alexa' assert event2['message'] == \ 'send command Alexa.PowerController/TurnOn for Kitchen Light' assert event2['entity_id'] == 'light.kitchen' assert event3['name'] == 'Amazon Alexa' assert event3['message'] == \ 'send command Alexa.PowerController/TurnOn for light.non_existing' assert event3['entity_id'] == 'light.non_existing'
async def test_humanify_script_started_event(hass): """Test humanifying Script Run event.""" event1, event2 = list(logbook.humanify(hass, [ ha.Event(EVENT_SCRIPT_STARTED, { ATTR_ENTITY_ID: 'script.hello', ATTR_NAME: 'Hello Script' }), ha.Event(EVENT_SCRIPT_STARTED, { ATTR_ENTITY_ID: 'script.bye', ATTR_NAME: 'Bye Script' }), ])) assert event1['name'] == 'Hello Script' assert event1['domain'] == 'script' assert event1['message'] == 'started' assert event1['entity_id'] == 'script.hello' assert event2['name'] == 'Bye Script' assert event2['domain'] == 'script' assert event2['message'] == 'started' assert event2['entity_id'] == 'script.bye'
def test_include_events_domain(self): """Test if events are filtered if domain is included in config.""" entity_id = 'switch.bla' entity_id2 = 'sensor.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) event_alexa = ha.Event(EVENT_ALEXA_SMART_HOME, {'request': { 'namespace': 'Alexa.Discovery', 'name': 'Discover', }}) event_homekit = ha.Event(EVENT_HOMEKIT_CHANGED, { ATTR_ENTITY_ID: 'lock.front_door', ATTR_DISPLAY_NAME: 'Front Door', ATTR_SERVICE: 'lock', }) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointB, entity_id2, 20) config = logbook.CONFIG_SCHEMA({ ha.DOMAIN: {}, logbook.DOMAIN: {logbook.CONF_INCLUDE: { logbook.CONF_DOMAINS: ['sensor', 'alexa', DOMAIN_HOMEKIT]}}}) entities_filter = logbook._generate_filter_from_config( config[logbook.DOMAIN]) events = [e for e in (ha.Event(EVENT_HOMEASSISTANT_START), event_alexa, event_homekit, eventA, eventB) if logbook._keep_event(e, entities_filter)] entries = list(logbook.humanify(self.hass, events)) assert 4 == len(entries) self.assert_entry(entries[0], name='Home Assistant', message='started', domain=ha.DOMAIN) self.assert_entry(entries[1], name='Amazon Alexa', domain='alexa') self.assert_entry(entries[2], name='HomeKit', domain=DOMAIN_HOMEKIT) self.assert_entry(entries[3], pointB, 'blu', domain='sensor', entity_id=entity_id2)
async def test_humanify_automation_triggered_event(hass): """Test humanifying Automation Trigger event.""" event1, event2 = list(logbook.humanify(hass, [ ha.Event(EVENT_AUTOMATION_TRIGGERED, { ATTR_ENTITY_ID: 'automation.hello', ATTR_NAME: 'Hello Automation', }), ha.Event(EVENT_AUTOMATION_TRIGGERED, { ATTR_ENTITY_ID: 'automation.bye', ATTR_NAME: 'Bye Automation', }), ])) assert event1['name'] == 'Hello Automation' assert event1['domain'] == 'automation' assert event1['message'] == 'has been triggered' assert event1['entity_id'] == 'automation.hello' assert event2['name'] == 'Bye Automation' assert event2['domain'] == 'automation' assert event2['message'] == 'has been triggered' assert event2['entity_id'] == 'automation.bye'
async def test_humanify_homekit_changed_event(hass, hk_driver): """Test humanifying HomeKit changed event.""" with patch("homeassistant.components.homekit.HomeKit"): assert await async_setup_component(hass, "homekit", {"homekit": {}}) event1, event2 = list( logbook.humanify( hass, [ ha.Event( EVENT_HOMEKIT_CHANGED, { ATTR_ENTITY_ID: "lock.front_door", ATTR_DISPLAY_NAME: "Front Door", ATTR_SERVICE: "lock", }, ), ha.Event( EVENT_HOMEKIT_CHANGED, { ATTR_ENTITY_ID: "cover.window", ATTR_DISPLAY_NAME: "Window", ATTR_SERVICE: "set_cover_position", ATTR_VALUE: 75, }, ), ], )) assert event1["name"] == "HomeKit" assert event1["domain"] == DOMAIN_HOMEKIT assert event1["message"] == "send command lock for Front Door" assert event1["entity_id"] == "lock.front_door" assert event2["name"] == "HomeKit" assert event2["domain"] == DOMAIN_HOMEKIT assert event2[ "message"] == "send command set_cover_position to 75 for Window" assert event2["entity_id"] == "cover.window"
def test_exclude_new_entities(self): """Test if events are excluded on first update.""" entity_id = 'sensor.bla' entity_id2 = 'sensor.blu' pointA = dt_util.utcnow() pointB = pointA + timedelta(minutes=logbook.GROUP_BY_MINUTES) eventA = self.create_state_changed_event(pointA, entity_id, 10) eventB = self.create_state_changed_event(pointB, entity_id2, 20) eventA.data['old_state'] = None events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_STOP), eventA, eventB), logbook._generate_filter_from_config({})) entries = list(logbook.humanify(self.hass, events)) assert 2 == len(entries) self.assert_entry( entries[0], name='Home Assistant', message='stopped', domain=ha.DOMAIN) self.assert_entry( entries[1], pointB, 'blu', domain='sensor', entity_id=entity_id2)
def test_exclude_automation_events(self): """Test if automation entries can be excluded by entity_id.""" name = 'My Automation Rule' message = 'has been triggered' domain = 'automation' entity_id = 'automation.my_automation_rule' entity_id2 = 'automation.my_automation_rule_2' entity_id2 = 'sensor.blu' eventA = ha.Event(logbook.EVENT_LOGBOOK_ENTRY, { logbook.ATTR_NAME: name, logbook.ATTR_MESSAGE: message, logbook.ATTR_DOMAIN: domain, logbook.ATTR_ENTITY_ID: entity_id, }) eventB = ha.Event(logbook.EVENT_LOGBOOK_ENTRY, { logbook.ATTR_NAME: name, logbook.ATTR_MESSAGE: message, logbook.ATTR_DOMAIN: domain, logbook.ATTR_ENTITY_ID: entity_id2, }) config = logbook.CONFIG_SCHEMA({ ha.DOMAIN: {}, logbook.DOMAIN: {logbook.CONF_EXCLUDE: { logbook.CONF_ENTITIES: [entity_id, ]}}}) events = logbook._exclude_events( (ha.Event(EVENT_HOMEASSISTANT_STOP), eventA, eventB), config[logbook.DOMAIN]) entries = list(logbook.humanify(self.hass, events)) self.assertEqual(2, len(entries)) self.assert_entry( entries[0], name='Home Assistant', message='stopped', domain=ha.DOMAIN) self.assert_entry( entries[1], name=name, domain=domain, entity_id=entity_id2)