def test_reproduce_turn_off(self): """Test reproduce_state with SERVICE_TURN_OFF.""" calls = mock_service(self.hass, 'light', SERVICE_TURN_OFF) self.hass.states.set('light.test', 'on') state.reproduce_state(self.hass, ha.State('light.test', 'off')) self.hass.block_till_done() self.assertTrue(len(calls) > 0) last_call = calls[-1] self.assertEqual('light', last_call.domain) self.assertEqual(SERVICE_TURN_OFF, last_call.service) self.assertEqual(['light.test'], last_call.data.get('entity_id'))
def test_from_event_to_db_state(): """Test converting event to db state.""" state = ha.State("sensor.temperature", "18") event = ha.Event( EVENT_STATE_CHANGED, { "entity_id": "sensor.temperature", "old_state": None, "new_state": state }, context=state.context, ) # We don't restore context unless we need it by joining the # events table on the event_id for state_changed events state.context = ha.Context(id=None) assert state == States.from_event(event).to_native()
def test_from_event_to_delete_state(): """Test converting deleting state event to db state.""" event = ha.Event( EVENT_STATE_CHANGED, { "entity_id": "sensor.temperature", "old_state": ha.State("sensor.temperature", "18"), "new_state": None, }, ) db_state = States.from_event(event) assert db_state.entity_id == "sensor.temperature" assert db_state.state == "" assert db_state.last_changed == event.time_fired assert db_state.last_updated == event.time_fired
def test_reproduce_state_with_group(self): light_calls = mock_service(self.hass, 'light', SERVICE_TURN_ON) self.hass.states.set('group.test', 'off', {'entity_id': ['light.test1', 'light.test2']}) state.reproduce_state(self.hass, ha.State('group.test', 'on')) self.hass.pool.block_till_done() self.assertEqual(1, len(light_calls)) last_call = light_calls[-1] self.assertEqual('light', last_call.domain) self.assertEqual(SERVICE_TURN_ON, last_call.service) self.assertEqual(['light.test1', 'light.test2'], last_call.data.get('entity_id'))
async def test_run_select_service_optimistic_with_command_template( hass, mqtt_mock_entry_with_yaml_config): """Test that set_value service works in optimistic mode and with a command_template.""" topic = "test/select" fake_state = ha.State("select.test", "milk") with patch( "homeassistant.helpers.restore_state.RestoreEntity.async_get_last_state", return_value=fake_state, ): assert await async_setup_component( hass, select.DOMAIN, { "select": { "platform": "mqtt", "command_topic": topic, "name": "Test Select", "options": ["milk", "beer"], "command_template": '{"option": "{{ value }}"}', } }, ) await hass.async_block_till_done() mqtt_mock = await mqtt_mock_entry_with_yaml_config() state = hass.states.get("select.test_select") assert state.state == "milk" assert state.attributes.get(ATTR_ASSUMED_STATE) await hass.services.async_call( SELECT_DOMAIN, SERVICE_SELECT_OPTION, { ATTR_ENTITY_ID: "select.test_select", ATTR_OPTION: "beer" }, blocking=True, ) mqtt_mock.async_publish.assert_called_once_with(topic, '{"option": "beer"}', 0, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("select.test_select") assert state.state == "beer"
def test_reproduce_group(self): """Test reproduce_state with group.""" light_calls = mock_service(self.hass, 'light', SERVICE_TURN_ON) self.hass.states.set('group.test', 'off', {'entity_id': ['light.test1', 'light.test2']}) state.reproduce_state(self.hass, ha.State('group.test', 'on')) self.hass.block_till_done() assert 1 == len(light_calls) last_call = light_calls[-1] assert 'light' == last_call.domain assert SERVICE_TURN_ON == last_call.service assert ['light.test1', 'light.test2'] == \ last_call.data.get('entity_id')
def test_reproduce_state_with_complex_service_data(self): calls = mock_service(self.hass, 'light', SERVICE_TURN_ON) self.hass.states.set('light.test', 'off') complex_data = ['hello', {'11': '22'}] state.reproduce_state( self.hass, ha.State('light.test', 'on', {'complex': complex_data})) self.hass.pool.block_till_done() self.assertTrue(len(calls) > 0) last_call = calls[-1] self.assertEqual('light', last_call.domain) self.assertEqual(SERVICE_TURN_ON, last_call.service) self.assertEqual(complex_data, last_call.data.get('complex'))
def test_reproduce_media_pause(self): """Test reproduce_state with SERVICE_MEDIA_PAUSE.""" calls = mock_service(self.hass, 'media_player', SERVICE_MEDIA_PAUSE) self.hass.states.set('media_player.test', 'playing') state.reproduce_state(self.hass, ha.State('media_player.test', 'paused')) self.hass.block_till_done() self.assertTrue(len(calls) > 0) last_call = calls[-1] self.assertEqual('media_player', last_call.domain) self.assertEqual(SERVICE_MEDIA_PAUSE, last_call.service) self.assertEqual(['media_player.test'], last_call.data.get('entity_id'))
def test_reproduce_media_pause(self): """Test reproduce_state with SERVICE_MEDIA_PAUSE.""" calls = mock_service(self.hass, 'media_player', SERVICE_MEDIA_PAUSE) self.hass.states.set('media_player.test', 'playing') state.reproduce_state(self.hass, ha.State('media_player.test', 'paused')) self.hass.block_till_done() assert len(calls) > 0 last_call = calls[-1] assert 'media_player' == last_call.domain assert SERVICE_MEDIA_PAUSE == last_call.service assert ['media_player.test'] == \ last_call.data.get('entity_id')
def test_event_listener_attr_details(self, mock_client): """Test event listener.""" config = { 'statsd': { 'host': 'host', 'log_attributes': True } } config['statsd'][statsd.CONF_RATE] = statsd.DEFAULT_RATE self.hass.bus.listen = mock.MagicMock() setup_component(self.hass, statsd.DOMAIN, config) self.assertTrue(self.hass.bus.listen.called) handler_method = self.hass.bus.listen.call_args_list[0][0][1] valid = {'1': 1, '1.0': 1.0, STATE_ON: 1, STATE_OFF: 0} for in_, out in valid.items(): state = mock.MagicMock(state=in_, attributes={"attribute key": 3.2}) handler_method(mock.MagicMock(data={'new_state': state})) mock_client.return_value.gauge.assert_has_calls([ mock.call("%s.state" % state.entity_id, out, statsd.DEFAULT_RATE), mock.call("%s.attribute_key" % state.entity_id, 3.2, statsd.DEFAULT_RATE), ]) mock_client.return_value.gauge.reset_mock() self.assertEqual(mock_client.return_value.incr.call_count, 1) self.assertEqual( mock_client.return_value.incr.call_args, mock.call(state.entity_id, rate=statsd.DEFAULT_RATE) ) mock_client.return_value.incr.reset_mock() for invalid in ('foo', '', object): handler_method(mock.MagicMock(data={ 'new_state': ha.State('domain.test', invalid, {})})) self.assertFalse(mock_client.return_value.gauge.called) self.assertTrue(mock_client.return_value.incr.called)
async def test_reproduce_complex_data(hass): """Test reproduce_state with complex service data.""" calls = async_mock_service(hass, 'light', SERVICE_TURN_ON) hass.states.async_set('light.test', 'off') complex_data = ['hello', {'11': '22'}] await state.async_reproduce_state( hass, ha.State('light.test', 'on', {'complex': complex_data})) await hass.async_block_till_done() assert len(calls) > 0 last_call = calls[-1] assert last_call.domain == 'light' assert SERVICE_TURN_ON == last_call.service assert complex_data == last_call.data.get('complex')
async def test_reproduce_complex_data(hass): """Test reproduce_state with complex service data.""" calls = async_mock_service(hass, "light", SERVICE_TURN_ON) hass.states.async_set("light.test", "off") complex_data = [255, 100, 100] await state.async_reproduce_state( hass, ha.State("light.test", "on", {"rgb_color": complex_data})) await hass.async_block_till_done() assert len(calls) > 0 last_call = calls[-1] assert last_call.domain == "light" assert last_call.service == SERVICE_TURN_ON assert last_call.data.get("rgb_color") == complex_data
async def test_reproduce_complex_data(hass): """Test reproduce_state with complex service data.""" calls = async_mock_service(hass, "light", SERVICE_TURN_ON) hass.states.async_set("light.test", "off") complex_data = ["hello", {"11": "22"}] await state.async_reproduce_state( hass, ha.State("light.test", "on", {"complex": complex_data})) await hass.async_block_till_done() assert len(calls) > 0 last_call = calls[-1] assert last_call.domain == "light" assert SERVICE_TURN_ON == last_call.service assert complex_data == last_call.data.get("complex")
def test_report_with_binary_state(self, mock_time): """Test the reporting with binary state.""" mock_time.return_value = 12345 state = ha.State('domain.entity', STATE_ON, {'foo': 1.0}) with mock.patch.object(self.gf, '_send_to_graphite') as mock_send: self.gf._report_attributes('entity', state) expected = ['ha.entity.foo 1.000000 12345', 'ha.entity.state 1.000000 12345'] actual = mock_send.call_args_list[0][0][0].split('\n') self.assertEqual(sorted(expected), sorted(actual)) state.state = STATE_OFF with mock.patch.object(self.gf, '_send_to_graphite') as mock_send: self.gf._report_attributes('entity', state) expected = ['ha.entity.foo 1.000000 12345', 'ha.entity.state 0.000000 12345'] actual = mock_send.call_args_list[0][0][0].split('\n') self.assertEqual(sorted(expected), sorted(actual))
def test_reproduce_complex_data(self): """Test reproduce_state with complex service data.""" calls = mock_service(self.hass, 'light', SERVICE_TURN_ON) self.hass.states.set('light.test', 'off') complex_data = ['hello', {'11': '22'}] state.reproduce_state( self.hass, ha.State('light.test', 'on', {'complex': complex_data})) self.hass.block_till_done() assert len(calls) > 0 last_call = calls[-1] assert 'light' == last_call.domain assert SERVICE_TURN_ON == last_call.service assert complex_data == last_call.data.get('complex')
async def test_sending_mqtt_commands_and_optimistic(hass, mqtt_mock): """Test the sending MQTT commands in optimistic mode.""" fake_state = ha.State("switch.test", "on") with patch( "homeassistant.helpers.restore_state.RestoreEntity.async_get_last_state", return_value=fake_state, ): assert await async_setup_component( hass, switch.DOMAIN, { switch.DOMAIN: { "platform": "mqtt", "name": "test", "command_topic": "command-topic", "payload_on": "beer on", "payload_off": "beer off", "qos": "2", } }, ) await hass.async_block_till_done() state = hass.states.get("switch.test") assert state.state == STATE_ON assert state.attributes.get(ATTR_ASSUMED_STATE) await common.async_turn_on(hass, "switch.test") mqtt_mock.async_publish.assert_called_once_with( "command-topic", "beer on", 2, False ) mqtt_mock.async_publish.reset_mock() state = hass.states.get("switch.test") assert state.state == STATE_ON await common.async_turn_off(hass, "switch.test") mqtt_mock.async_publish.assert_called_once_with( "command-topic", "beer off", 2, False ) state = hass.states.get("switch.test") assert state.state == STATE_OFF
def test_json_encoder(hass): """Test the JSON Encoder.""" ha_json_enc = JSONEncoder() state = core.State("test.test", "hello") # Test serializing a datetime now = dt_util.utcnow() assert ha_json_enc.default(now) == now.isoformat() # Test serializing a set() data = {"milk", "beer"} assert sorted(ha_json_enc.default(data)) == sorted(data) # Test serializing an object which implements as_dict assert ha_json_enc.default(state) == state.as_dict() # Default method raises TypeError if non HA object with pytest.raises(TypeError): ha_json_enc.default(1)
def create_state_changed_event(self, event_time_fired, entity_id, state, attributes=None, last_changed=None, last_updated=None): """Create state changed event.""" # Logbook only cares about state change events that # contain an old state but will not actually act on it. state = ha.State(entity_id, state, attributes, last_changed, last_updated).as_dict() return ha.Event(EVENT_STATE_CHANGED, { 'entity_id': entity_id, 'old_state': state, 'new_state': state, }, time_fired=event_time_fired)
def test_reproduce_media_data(self): """Test reproduce_state with SERVICE_PLAY_MEDIA.""" calls = mock_service(self.hass, 'media_player', SERVICE_PLAY_MEDIA) self.hass.states.set('media_player.test', 'off') media_attributes = {'media_content_type': 'movie', 'media_content_id': 'batman'} state.reproduce_state(self.hass, ha.State('media_player.test', 'None', media_attributes)) self.hass.pool.block_till_done() self.assertTrue(len(calls) > 0) last_call = calls[-1] self.assertEqual('media_player', last_call.domain) self.assertEqual(SERVICE_PLAY_MEDIA, last_call.service) self.assertEqual('movie', last_call.data.get('media_content_type')) self.assertEqual('batman', last_call.data.get('media_content_id'))
async def test_sending_mqtt_commands_and_optimistic( hass, mqtt_mock_entry_with_yaml_config): """Test the sending MQTT commands in optimistic mode.""" fake_state = ha.State("switch.test", "on") mock_restore_cache(hass, (fake_state, )) assert await async_setup_component( hass, switch.DOMAIN, { switch.DOMAIN: { "platform": "mqtt", "name": "test", "command_topic": "command-topic", "payload_on": "beer on", "payload_off": "beer off", "qos": "2", } }, ) await hass.async_block_till_done() mqtt_mock = await mqtt_mock_entry_with_yaml_config() state = hass.states.get("switch.test") assert state.state == STATE_ON assert state.attributes.get(ATTR_ASSUMED_STATE) await common.async_turn_on(hass, "switch.test") mqtt_mock.async_publish.assert_called_once_with("command-topic", "beer on", 2, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("switch.test") assert state.state == STATE_ON await common.async_turn_off(hass, "switch.test") mqtt_mock.async_publish.assert_called_once_with("command-topic", "beer off", 2, False) state = hass.states.get("switch.test") assert state.state == STATE_OFF
async def test_sending_mqtt_commands_and_optimistic(hass, mock_publish): """Test the sending MQTT commands in optimistic mode.""" fake_state = ha.State('switch.test', 'on') with patch( 'homeassistant.helpers.restore_state.RestoreEntity' '.async_get_last_state', return_value=mock_coro(fake_state)): assert await async_setup_component( hass, switch.DOMAIN, { switch.DOMAIN: { 'platform': 'mqtt', 'name': 'test', 'command_topic': 'command-topic', 'payload_on': 'beer on', 'payload_off': 'beer off', 'qos': '2' } }) state = hass.states.get('switch.test') assert STATE_ON == state.state assert state.attributes.get(ATTR_ASSUMED_STATE) common.turn_on(hass, 'switch.test') await hass.async_block_till_done() mock_publish.async_publish.assert_called_once_with('command-topic', 'beer on', 2, False) mock_publish.async_publish.reset_mock() state = hass.states.get('switch.test') assert STATE_ON == state.state common.turn_off(hass, 'switch.test') await hass.async_block_till_done() await hass.async_block_till_done() mock_publish.async_publish.assert_called_once_with('command-topic', 'beer off', 2, False) state = hass.states.get('switch.test') assert STATE_OFF == state.state
async def test_optimistic(hass, mqtt_mock): """Test optimistic mode.""" fake_state = ha.State('light.test', 'on', {'brightness': 95, 'hs_color': [100, 100], 'effect': 'random', 'color_temp': 100, 'white_value': 50}) with patch('homeassistant.helpers.restore_state.RestoreEntity' '.async_get_last_state', return_value=mock_coro(fake_state)): with assert_setup_component(1, light.DOMAIN): assert await async_setup_component(hass, light.DOMAIN, { light.DOMAIN: { 'platform': 'mqtt', 'schema': 'template', 'name': 'test', 'command_topic': 'test_light_rgb/set', 'command_on_template': 'on,' '{{ brightness|d }},' '{{ color_temp|d }},' '{{ white_value|d }},' '{{ red|d }}-' '{{ green|d }}-' '{{ blue|d }}', 'command_off_template': 'off', 'effect_list': ['colorloop', 'random'], 'effect_command_topic': 'test_light_rgb/effect/set', 'qos': 2 } }) state = hass.states.get('light.test') assert STATE_ON == state.state assert 95 == state.attributes.get('brightness') assert (100, 100) == state.attributes.get('hs_color') assert 'random' == state.attributes.get('effect') assert 100 == state.attributes.get('color_temp') assert 50 == state.attributes.get('white_value') assert state.attributes.get(ATTR_ASSUMED_STATE)
async def test_sending_mqtt_commands_and_optimistic(hass, mqtt_mock): """Test the sending of command in optimistic mode.""" fake_state = ha.State( 'light.test', 'on', { 'brightness': 95, 'hs_color': [100, 100], 'effect': 'random', 'color_temp': 100, 'white_value': 50 }) with patch( 'homeassistant.helpers.restore_state.RestoreEntity' '.async_get_last_state', return_value=mock_coro(fake_state)): assert await async_setup_component( hass, light.DOMAIN, { light.DOMAIN: { 'platform': 'mqtt', 'schema': 'json', 'name': 'test', 'command_topic': 'test_light_rgb/set', 'brightness': True, 'color_temp': True, 'effect': True, 'rgb': True, 'white_value': True, 'qos': 2 } }) state = hass.states.get('light.test') assert STATE_ON == state.state assert 95 == state.attributes.get('brightness') assert (100, 100) == state.attributes.get('hs_color') assert 'random' == state.attributes.get('effect') assert 100 == state.attributes.get('color_temp') assert 50 == state.attributes.get('white_value') assert 191 == state.attributes.get(ATTR_SUPPORTED_FEATURES) assert state.attributes.get(ATTR_ASSUMED_STATE)
def test_report_with_binary_state(self, mock_time): """Test the reporting with binary state.""" mock_time.return_value = 12345 state = ha.State("domain.entity", STATE_ON, {"foo": 1.0}) with mock.patch.object(self.gf, "_send_to_graphite") as mock_send: self.gf._report_attributes("entity", state) expected = [ "ha.entity.foo 1.000000 12345", "ha.entity.state 1.000000 12345", ] actual = mock_send.call_args_list[0][0][0].split("\n") assert sorted(expected) == sorted(actual) state.state = STATE_OFF with mock.patch.object(self.gf, "_send_to_graphite") as mock_send: self.gf._report_attributes("entity", state) expected = [ "ha.entity.foo 1.000000 12345", "ha.entity.state 0.000000 12345", ] actual = mock_send.call_args_list[0][0][0].split("\n") assert sorted(expected) == sorted(actual)
def test_reproduce_media_data(self): """Test reproduce_state with SERVICE_PLAY_MEDIA.""" calls = mock_service(self.hass, 'media_player', SERVICE_PLAY_MEDIA) self.hass.states.set('media_player.test', 'off') media_attributes = { 'media_content_type': 'movie', 'media_content_id': 'batman' } state.reproduce_state( self.hass, ha.State('media_player.test', 'None', media_attributes)) self.hass.block_till_done() assert len(calls) > 0 last_call = calls[-1] assert 'media_player' == last_call.domain assert SERVICE_PLAY_MEDIA == last_call.service assert 'movie' == last_call.data.get('media_content_type') assert 'batman' == last_call.data.get('media_content_id')
async def test_event_listener_attr_details(hass, mock_client): """Test event listener.""" config = {"statsd": {"host": "host", "log_attributes": True}} config["statsd"][statsd.CONF_RATE] = statsd.DEFAULT_RATE hass.bus.listen = MagicMock() await async_setup_component(hass, statsd.DOMAIN, config) assert hass.bus.listen.called handler_method = hass.bus.listen.call_args_list[0][0][1] valid = {"1": 1, "1.0": 1.0, STATE_ON: 1, STATE_OFF: 0} for in_, out in valid.items(): state = MagicMock(state=in_, attributes={"attribute key": 3.2}) handler_method(MagicMock(data={"new_state": state})) mock_client.gauge.assert_has_calls( [ mock.call("%s.state" % state.entity_id, out, statsd.DEFAULT_RATE), mock.call( "%s.attribute_key" % state.entity_id, 3.2, statsd.DEFAULT_RATE ), ] ) mock_client.gauge.reset_mock() assert mock_client.incr.call_count == 1 assert mock_client.incr.call_args == mock.call( state.entity_id, rate=statsd.DEFAULT_RATE ) mock_client.incr.reset_mock() for invalid in ("foo", "", object): handler_method( MagicMock(data={"new_state": ha.State("domain.test", invalid, {})}) ) assert not mock_client.gauge.called assert mock_client.incr.called
def test_sending_mqtt_commands_and_optimistic(self): """Test the sending MQTT commands in optimistic mode.""" fake_state = ha.State('switch.test', 'on') with patch('homeassistant.components.switch.mqtt.async_get_last_state', return_value=mock_coro(fake_state)): assert setup_component( self.hass, switch.DOMAIN, { switch.DOMAIN: { 'platform': 'mqtt', 'name': 'test', 'command_topic': 'command-topic', 'payload_on': 'beer on', 'payload_off': 'beer off', 'qos': '2' } }) state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE)) switch.turn_on(self.hass, 'switch.test') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'command-topic', 'beer on', 2, False) self.mock_publish.async_publish.reset_mock() state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.test') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'command-topic', 'beer off', 2, False) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state)
async def test_skip_restoring_state_with_over_due_expire_trigger( hass, mqtt_mock, caplog, freezer): """Test restoring a state with over due expire timer.""" freezer.move_to("2022-02-02 12:02:00+01:00") domain = sensor.DOMAIN config3 = copy.deepcopy(DEFAULT_CONFIG[domain]) config3["name"] = "test3" config3["expire_after"] = 10 config3["state_topic"] = "test-topic3" fake_state = ha.State( "sensor.test3", "300", {}, last_changed=datetime.fromisoformat("2022-02-02 12:01:35+01:00"), ) with patch( "homeassistant.helpers.restore_state.RestoreEntity.async_get_last_state", return_value=fake_state, ), assert_setup_component(1, domain): assert await async_setup_component(hass, domain, {domain: config3}) await hass.async_block_till_done() assert "Skip state recovery after reload for sensor.test3" in caplog.text
def test_event_listener_defaults(self, mock_client): """Test event listener.""" config = { 'statsd': { 'host': 'host', } } config['statsd'][statsd.CONF_RATE] = statsd.DEFAULT_RATE hass = mock.MagicMock() hass.pool.worker_count = 2 setup_component(hass, statsd.DOMAIN, config) self.assertTrue(hass.bus.listen.called) handler_method = hass.bus.listen.call_args_list[0][0][1] valid = {'1': 1, '1.0': 1.0, STATE_ON: 1, STATE_OFF: 0} for in_, out in valid.items(): state = mock.MagicMock(state=in_, attributes={"attribute key": 3.2}) handler_method(mock.MagicMock(data={'new_state': state})) mock_client.return_value.gauge.assert_has_calls([ mock.call(state.entity_id, out, statsd.DEFAULT_RATE), ]) mock_client.return_value.gauge.reset_mock() mock_client.return_value.incr.assert_called_once_with( state.entity_id, rate=statsd.DEFAULT_RATE) mock_client.return_value.incr.reset_mock() for invalid in ('foo', '', object): handler_method( mock.MagicMock( data={'new_state': ha.State('domain.test', invalid, {})})) self.assertFalse(mock_client.return_value.gauge.called) self.assertFalse(mock_client.return_value.incr.called)
async def test_run_select_service_optimistic(hass, mqtt_mock_entry_with_yaml_config): """Test that set_value service works in optimistic mode.""" topic = "test/select" fake_state = ha.State("select.test_select", "milk") mock_restore_cache(hass, (fake_state,)) assert await async_setup_component( hass, select.DOMAIN, { "select": { "platform": "mqtt", "command_topic": topic, "name": "Test Select", "options": ["milk", "beer"], } }, ) await hass.async_block_till_done() mqtt_mock = await mqtt_mock_entry_with_yaml_config() state = hass.states.get("select.test_select") assert state.state == "milk" assert state.attributes.get(ATTR_ASSUMED_STATE) await hass.services.async_call( SELECT_DOMAIN, SERVICE_SELECT_OPTION, {ATTR_ENTITY_ID: "select.test_select", ATTR_OPTION: "beer"}, blocking=True, ) mqtt_mock.async_publish.assert_called_once_with(topic, "beer", 0, False) mqtt_mock.async_publish.reset_mock() state = hass.states.get("select.test_select") assert state.state == "beer"