jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-25 06:07:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

review comments. (#52337)

Browse Source
This commit is contained in:
jan iversen 2021-06-30 14:34:33 +02:00 committed by GitHub
parent 0476c7f9ee
commit c0751c060f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 193 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
tests/components/modbus/test_binary_sensor.py
View File

@ -21,8 +21,8 @@ from homeassistant.core import State
from .conftest import ReadResult, base_test, prepare_service_update from .conftest import ReadResult, base_test, prepare_service_update
sensor_name = "test_binary_sensor" SENSOR_NAME = "test_binary_sensor"
entity_id = f"{SENSOR_DOMAIN}.{sensor_name}" ENTITY_ID = f"{SENSOR_DOMAIN}.{SENSOR_NAME}"
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -31,7 +31,7 @@ entity_id = f"{SENSOR_DOMAIN}.{sensor_name}"
{ {
CONF_BINARY_SENSORS: [ CONF_BINARY_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 51, CONF_ADDRESS: 51,
} }
] ]
@ -39,7 +39,7 @@ entity_id = f"{SENSOR_DOMAIN}.{sensor_name}"
{ {
CONF_BINARY_SENSORS: [ CONF_BINARY_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 51, CONF_ADDRESS: 51,
CONF_SLAVE: 10, CONF_SLAVE: 10,
CONF_INPUT_TYPE: CALL_TYPE_DISCRETE, CONF_INPUT_TYPE: CALL_TYPE_DISCRETE,
@ -88,8 +88,8 @@ async def test_all_binary_sensor(hass, do_type, regs, expected):
"""Run test for given config.""" """Run test for given config."""
state = await base_test( state = await base_test(
hass, hass,
{CONF_NAME: sensor_name, CONF_ADDRESS: 1234, CONF_INPUT_TYPE: do_type}, {CONF_NAME: SENSOR_NAME, CONF_ADDRESS: 1234, CONF_INPUT_TYPE: do_type},
sensor_name, SENSOR_NAME,
SENSOR_DOMAIN, SENSOR_DOMAIN,
CONF_BINARY_SENSORS, CONF_BINARY_SENSORS,
None, None,
@ -107,7 +107,7 @@ async def test_service_binary_sensor_update(hass, mock_pymodbus):
config = { config = {
CONF_BINARY_SENSORS: [ CONF_BINARY_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_INPUT_TYPE: CALL_TYPE_COIL, CONF_INPUT_TYPE: CALL_TYPE_COIL,
} }
@ -119,21 +119,21 @@ async def test_service_binary_sensor_update(hass, mock_pymodbus):
config, config,
) )
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_OFF assert hass.states.get(ENTITY_ID).state == STATE_OFF
mock_pymodbus.read_coils.return_value = ReadResult([0x01]) mock_pymodbus.read_coils.return_value = ReadResult([0x01])
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == STATE_ON assert hass.states.get(ENTITY_ID).state == STATE_ON
@pytest.mark.parametrize( @pytest.mark.parametrize(
"mock_test_state", "mock_test_state",
[(State(entity_id, STATE_ON),)], [(State(ENTITY_ID, STATE_ON),)],
indirect=True, indirect=True,
) )
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -142,7 +142,7 @@ async def test_service_binary_sensor_update(hass, mock_pymodbus):
{ {
CONF_BINARY_SENSORS: [ CONF_BINARY_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 51, CONF_ADDRESS: 51,
} }
] ]
@ -151,4 +151,4 @@ async def test_service_binary_sensor_update(hass, mock_pymodbus):
) )
async def test_restore_state_binary_sensor(hass, mock_test_state, mock_modbus): async def test_restore_state_binary_sensor(hass, mock_test_state, mock_modbus):
"""Run test for binary sensor restore state.""" """Run test for binary sensor restore state."""
assert hass.states.get(entity_id).state == mock_test_state[0].state assert hass.states.get(ENTITY_ID).state == mock_test_state[0].state

26
tests/components/modbus/test_climate.py
View File

@ -16,8 +16,8 @@ from homeassistant.core import State
from .conftest import ReadResult, base_test, prepare_service_update from .conftest import ReadResult, base_test, prepare_service_update
climate_name = "test_climate" CLIMATE_NAME = "test_climate"
entity_id = f"{CLIMATE_DOMAIN}.{climate_name}" ENTITY_ID = f"{CLIMATE_DOMAIN}.{CLIMATE_NAME}"
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -26,7 +26,7 @@ entity_id = f"{CLIMATE_DOMAIN}.{climate_name}"
{ {
CONF_CLIMATES: [ CONF_CLIMATES: [
{ {
CONF_NAME: climate_name, CONF_NAME: CLIMATE_NAME,
CONF_TARGET_TEMP: 117, CONF_TARGET_TEMP: 117,
CONF_ADDRESS: 117, CONF_ADDRESS: 117,
CONF_SLAVE: 10, CONF_SLAVE: 10,
@ -36,7 +36,7 @@ entity_id = f"{CLIMATE_DOMAIN}.{climate_name}"
{ {
CONF_CLIMATES: [ CONF_CLIMATES: [
{ {
CONF_NAME: climate_name, CONF_NAME: CLIMATE_NAME,
CONF_TARGET_TEMP: 117, CONF_TARGET_TEMP: 117,
CONF_ADDRESS: 117, CONF_ADDRESS: 117,
CONF_SLAVE: 10, CONF_SLAVE: 10,
@ -63,18 +63,18 @@ async def test_config_climate(hass, mock_modbus):
) )
async def test_temperature_climate(hass, regs, expected): async def test_temperature_climate(hass, regs, expected):
"""Run test for given config.""" """Run test for given config."""
climate_name = "modbus_test_climate" CLIMATE_NAME = "modbus_test_climate"
return return
state = await base_test( state = await base_test(
hass, hass,
{ {
CONF_NAME: climate_name, CONF_NAME: CLIMATE_NAME,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_TARGET_TEMP: 117, CONF_TARGET_TEMP: 117,
CONF_ADDRESS: 117, CONF_ADDRESS: 117,
CONF_COUNT: 2, CONF_COUNT: 2,
}, },
climate_name, CLIMATE_NAME,
CLIMATE_DOMAIN, CLIMATE_DOMAIN,
CONF_CLIMATES, CONF_CLIMATES,
None, None,
@ -92,7 +92,7 @@ async def test_service_climate_update(hass, mock_pymodbus):
config = { config = {
CONF_CLIMATES: [ CONF_CLIMATES: [
{ {
CONF_NAME: climate_name, CONF_NAME: CLIMATE_NAME,
CONF_TARGET_TEMP: 117, CONF_TARGET_TEMP: 117,
CONF_ADDRESS: 117, CONF_ADDRESS: 117,
CONF_SLAVE: 10, CONF_SLAVE: 10,
@ -105,12 +105,12 @@ async def test_service_climate_update(hass, mock_pymodbus):
config, config,
) )
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == "auto" assert hass.states.get(ENTITY_ID).state == "auto"
test_value = State(entity_id, 35) test_value = State(ENTITY_ID, 35)
test_value.attributes = {ATTR_TEMPERATURE: 37} test_value.attributes = {ATTR_TEMPERATURE: 37}
@ -125,7 +125,7 @@ test_value.attributes = {ATTR_TEMPERATURE: 37}
{ {
CONF_CLIMATES: [ CONF_CLIMATES: [
{ {
CONF_NAME: climate_name, CONF_NAME: CLIMATE_NAME,
CONF_TARGET_TEMP: 117, CONF_TARGET_TEMP: 117,
CONF_ADDRESS: 117, CONF_ADDRESS: 117,
} }
@ -135,6 +135,6 @@ test_value.attributes = {ATTR_TEMPERATURE: 37}
) )
async def test_restore_state_climate(hass, mock_test_state, mock_modbus): async def test_restore_state_climate(hass, mock_test_state, mock_modbus):
"""Run test for sensor restore state.""" """Run test for sensor restore state."""
state = hass.states.get(entity_id) state = hass.states.get(ENTITY_ID)
assert state.state == HVAC_MODE_AUTO assert state.state == HVAC_MODE_AUTO
assert state.attributes[ATTR_TEMPERATURE] == 37 assert state.attributes[ATTR_TEMPERATURE] == 37

60
tests/components/modbus/test_cover.py
View File

@ -31,8 +31,8 @@ from homeassistant.core import State
from .conftest import ReadResult, base_test, prepare_service_update from .conftest import ReadResult, base_test, prepare_service_update
cover_name = "test_cover" COVER_NAME = "test_cover"
entity_id = f"{COVER_DOMAIN}.{cover_name}" ENTITY_ID = f"{COVER_DOMAIN}.{COVER_NAME}"
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -41,7 +41,7 @@ entity_id = f"{COVER_DOMAIN}.{cover_name}"
{ {
CONF_COVERS: [ CONF_COVERS: [
{ {
CONF_NAME: cover_name, CONF_NAME: COVER_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_INPUT_TYPE: CALL_TYPE_COIL, CONF_INPUT_TYPE: CALL_TYPE_COIL,
} }
@ -50,7 +50,7 @@ entity_id = f"{COVER_DOMAIN}.{cover_name}"
{ {
CONF_COVERS: [ CONF_COVERS: [
{ {
CONF_NAME: cover_name, CONF_NAME: COVER_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_INPUT_TYPE: CALL_TYPE_REGISTER_HOLDING,
CONF_SLAVE: 10, CONF_SLAVE: 10,
@ -95,12 +95,12 @@ async def test_coil_cover(hass, regs, expected):
state = await base_test( state = await base_test(
hass, hass,
{ {
CONF_NAME: cover_name, CONF_NAME: COVER_NAME,
CONF_INPUT_TYPE: CALL_TYPE_COIL, CONF_INPUT_TYPE: CALL_TYPE_COIL,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
}, },
cover_name, COVER_NAME,
COVER_DOMAIN, COVER_DOMAIN,
CONF_COVERS, CONF_COVERS,
None, None,
@ -142,11 +142,11 @@ async def test_register_cover(hass, regs, expected):
state = await base_test( state = await base_test(
hass, hass,
{ {
CONF_NAME: cover_name, CONF_NAME: COVER_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
}, },
cover_name, COVER_NAME,
COVER_DOMAIN, COVER_DOMAIN,
CONF_COVERS, CONF_COVERS,
None, None,
@ -164,7 +164,7 @@ async def test_service_cover_update(hass, mock_pymodbus):
config = { config = {
CONF_COVERS: [ CONF_COVERS: [
{ {
CONF_NAME: cover_name, CONF_NAME: COVER_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_STATUS_REGISTER_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_STATUS_REGISTER_TYPE: CALL_TYPE_REGISTER_HOLDING,
} }
@ -176,23 +176,23 @@ async def test_service_cover_update(hass, mock_pymodbus):
config, config,
) )
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == STATE_CLOSED assert hass.states.get(ENTITY_ID).state == STATE_CLOSED
mock_pymodbus.read_holding_registers.return_value = ReadResult([0x01]) mock_pymodbus.read_holding_registers.return_value = ReadResult([0x01])
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == STATE_OPEN assert hass.states.get(ENTITY_ID).state == STATE_OPEN
@pytest.mark.parametrize( @pytest.mark.parametrize(
"mock_test_state", "mock_test_state",
[ [
(State(entity_id, STATE_CLOSED),), (State(ENTITY_ID, STATE_CLOSED),),
(State(entity_id, STATE_CLOSING),), (State(ENTITY_ID, STATE_CLOSING),),
(State(entity_id, STATE_OPENING),), (State(ENTITY_ID, STATE_OPENING),),
(State(entity_id, STATE_OPEN),), (State(ENTITY_ID, STATE_OPEN),),
], ],
indirect=True, indirect=True,
) )
@ -202,7 +202,7 @@ async def test_service_cover_update(hass, mock_pymodbus):
{ {
CONF_COVERS: [ CONF_COVERS: [
{ {
CONF_NAME: cover_name, CONF_NAME: COVER_NAME,
CONF_INPUT_TYPE: CALL_TYPE_COIL, CONF_INPUT_TYPE: CALL_TYPE_COIL,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_STATE_OPEN: 1, CONF_STATE_OPEN: 1,
@ -219,22 +219,22 @@ async def test_service_cover_update(hass, mock_pymodbus):
async def test_restore_state_cover(hass, mock_test_state, mock_modbus): async def test_restore_state_cover(hass, mock_test_state, mock_modbus):
"""Run test for cover restore state.""" """Run test for cover restore state."""
test_state = mock_test_state[0].state test_state = mock_test_state[0].state
assert hass.states.get(entity_id).state == test_state assert hass.states.get(ENTITY_ID).state == test_state
async def test_service_cover_move(hass, mock_pymodbus): async def test_service_cover_move(hass, mock_pymodbus):
"""Run test for service homeassistant.update_entity.""" """Run test for service homeassistant.update_entity."""
entity_id2 = f"{entity_id}2" ENTITY_ID2 = f"{ENTITY_ID}2"
config = { config = {
CONF_COVERS: [ CONF_COVERS: [
{ {
CONF_NAME: cover_name, CONF_NAME: COVER_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_STATUS_REGISTER_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_STATUS_REGISTER_TYPE: CALL_TYPE_REGISTER_HOLDING,
}, },
{ {
CONF_NAME: f"{cover_name}2", CONF_NAME: f"{COVER_NAME}2",
CONF_INPUT_TYPE: CALL_TYPE_COIL, CONF_INPUT_TYPE: CALL_TYPE_COIL,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
}, },
@ -246,26 +246,26 @@ async def test_service_cover_move(hass, mock_pymodbus):
config, config,
) )
await hass.services.async_call( await hass.services.async_call(
"cover", "open_cover", {"entity_id": entity_id}, blocking=True "cover", "open_cover", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == STATE_OPEN assert hass.states.get(ENTITY_ID).state == STATE_OPEN
mock_pymodbus.read_holding_registers.return_value = ReadResult([0x00]) mock_pymodbus.read_holding_registers.return_value = ReadResult([0x00])
await hass.services.async_call( await hass.services.async_call(
"cover", "close_cover", {"entity_id": entity_id}, blocking=True "cover", "close_cover", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == STATE_CLOSED assert hass.states.get(ENTITY_ID).state == STATE_CLOSED
mock_pymodbus.reset() mock_pymodbus.reset()
mock_pymodbus.read_holding_registers.side_effect = ModbusException("fail write_") mock_pymodbus.read_holding_registers.side_effect = ModbusException("fail write_")
await hass.services.async_call( await hass.services.async_call(
"cover", "close_cover", {"entity_id": entity_id}, blocking=True "cover", "close_cover", {"entity_id": ENTITY_ID}, blocking=True
) )
assert mock_pymodbus.read_holding_registers.called assert mock_pymodbus.read_holding_registers.called
assert hass.states.get(entity_id).state == STATE_UNAVAILABLE assert hass.states.get(ENTITY_ID).state == STATE_UNAVAILABLE
mock_pymodbus.read_coils.side_effect = ModbusException("fail write_") mock_pymodbus.read_coils.side_effect = ModbusException("fail write_")
await hass.services.async_call( await hass.services.async_call(
"cover", "close_cover", {"entity_id": entity_id2}, blocking=True "cover", "close_cover", {"entity_id": ENTITY_ID2}, blocking=True
) )
assert hass.states.get(entity_id2).state == STATE_UNAVAILABLE assert hass.states.get(ENTITY_ID2).state == STATE_UNAVAILABLE

70
tests/components/modbus/test_fan.py
View File

@ -34,8 +34,8 @@ from homeassistant.setup import async_setup_component
from .conftest import ReadResult, base_test, prepare_service_update from .conftest import ReadResult, base_test, prepare_service_update
fan_name = "test_fan" FAN_NAME = "test_fan"
entity_id = f"{FAN_DOMAIN}.{fan_name}" ENTITY_ID = f"{FAN_DOMAIN}.{FAN_NAME}"
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -44,7 +44,7 @@ entity_id = f"{FAN_DOMAIN}.{fan_name}"
{ {
CONF_FANS: [ CONF_FANS: [
{ {
CONF_NAME: fan_name, CONF_NAME: FAN_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
} }
] ]
@ -52,7 +52,7 @@ entity_id = f"{FAN_DOMAIN}.{fan_name}"
{ {
CONF_FANS: [ CONF_FANS: [
{ {
CONF_NAME: fan_name, CONF_NAME: FAN_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_WRITE_TYPE: CALL_TYPE_COIL, CONF_WRITE_TYPE: CALL_TYPE_COIL,
} }
@ -61,7 +61,7 @@ entity_id = f"{FAN_DOMAIN}.{fan_name}"
{ {
CONF_FANS: [ CONF_FANS: [
{ {
CONF_NAME: fan_name, CONF_NAME: FAN_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00, CONF_COMMAND_OFF: 0x00,
@ -78,7 +78,7 @@ entity_id = f"{FAN_DOMAIN}.{fan_name}"
{ {
CONF_FANS: [ CONF_FANS: [
{ {
CONF_NAME: fan_name, CONF_NAME: FAN_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00, CONF_COMMAND_OFF: 0x00,
@ -95,7 +95,7 @@ entity_id = f"{FAN_DOMAIN}.{fan_name}"
{ {
CONF_FANS: [ CONF_FANS: [
{ {
CONF_NAME: fan_name, CONF_NAME: FAN_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00, CONF_COMMAND_OFF: 0x00,
@ -112,7 +112,7 @@ entity_id = f"{FAN_DOMAIN}.{fan_name}"
{ {
CONF_FANS: [ CONF_FANS: [
{ {
CONF_NAME: fan_name, CONF_NAME: FAN_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00, CONF_COMMAND_OFF: 0x00,
@ -164,13 +164,13 @@ async def test_all_fan(hass, call_type, regs, verify, expected):
state = await base_test( state = await base_test(
hass, hass,
{ {
CONF_NAME: fan_name, CONF_NAME: FAN_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_WRITE_TYPE: call_type, CONF_WRITE_TYPE: call_type,
**verify, **verify,
}, },
fan_name, FAN_NAME,
FAN_DOMAIN, FAN_DOMAIN,
CONF_FANS, CONF_FANS,
None, None,
@ -184,7 +184,7 @@ async def test_all_fan(hass, call_type, regs, verify, expected):
@pytest.mark.parametrize( @pytest.mark.parametrize(
"mock_test_state", "mock_test_state",
[(State(entity_id, STATE_ON),)], [(State(ENTITY_ID, STATE_ON),)],
indirect=True, indirect=True,
) )
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -193,7 +193,7 @@ async def test_all_fan(hass, call_type, regs, verify, expected):
{ {
CONF_FANS: [ CONF_FANS: [
{ {
CONF_NAME: fan_name, CONF_NAME: FAN_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
} }
] ]
@ -202,13 +202,13 @@ async def test_all_fan(hass, call_type, regs, verify, expected):
) )
async def test_restore_state_fan(hass, mock_test_state, mock_modbus): async def test_restore_state_fan(hass, mock_test_state, mock_modbus):
"""Run test for fan restore state.""" """Run test for fan restore state."""
assert hass.states.get(entity_id).state == STATE_ON assert hass.states.get(ENTITY_ID).state == STATE_ON
async def test_fan_service_turn(hass, caplog, mock_pymodbus): async def test_fan_service_turn(hass, caplog, mock_pymodbus):
"""Run test for service turn_on/turn_off.""" """Run test for service turn_on/turn_off."""
entity_id2 = f"{FAN_DOMAIN}.{fan_name}2" ENTITY_ID2 = f"{FAN_DOMAIN}.{FAN_NAME}2"
config = { config = {
MODBUS_DOMAIN: { MODBUS_DOMAIN: {
CONF_TYPE: "tcp", CONF_TYPE: "tcp",
@ -216,12 +216,12 @@ async def test_fan_service_turn(hass, caplog, mock_pymodbus):
CONF_PORT: 5501, CONF_PORT: 5501,
CONF_FANS: [ CONF_FANS: [
{ {
CONF_NAME: fan_name, CONF_NAME: FAN_NAME,
CONF_ADDRESS: 17, CONF_ADDRESS: 17,
CONF_WRITE_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_WRITE_TYPE: CALL_TYPE_REGISTER_HOLDING,
}, },
{ {
CONF_NAME: f"{fan_name}2", CONF_NAME: f"{FAN_NAME}2",
CONF_ADDRESS: 17, CONF_ADDRESS: 17,
CONF_WRITE_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_WRITE_TYPE: CALL_TYPE_REGISTER_HOLDING,
CONF_VERIFY: {}, CONF_VERIFY: {},
@ -233,44 +233,44 @@ async def test_fan_service_turn(hass, caplog, mock_pymodbus):
await hass.async_block_till_done() await hass.async_block_till_done()
assert MODBUS_DOMAIN in hass.config.components assert MODBUS_DOMAIN in hass.config.components
assert hass.states.get(entity_id).state == STATE_OFF assert hass.states.get(ENTITY_ID).state == STATE_OFF
await hass.services.async_call( await hass.services.async_call(
"fan", "turn_on", service_data={"entity_id": entity_id} "fan", "turn_on", service_data={"entity_id": ENTITY_ID}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_ON assert hass.states.get(ENTITY_ID).state == STATE_ON
await hass.services.async_call( await hass.services.async_call(
"fan", "turn_off", service_data={"entity_id": entity_id} "fan", "turn_off", service_data={"entity_id": ENTITY_ID}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_OFF assert hass.states.get(ENTITY_ID).state == STATE_OFF
mock_pymodbus.read_holding_registers.return_value = ReadResult([0x01]) mock_pymodbus.read_holding_registers.return_value = ReadResult([0x01])
assert hass.states.get(entity_id2).state == STATE_OFF assert hass.states.get(ENTITY_ID2).state == STATE_OFF
await hass.services.async_call( await hass.services.async_call(
"fan", "turn_on", service_data={"entity_id": entity_id2} "fan", "turn_on", service_data={"entity_id": ENTITY_ID2}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id2).state == STATE_ON assert hass.states.get(ENTITY_ID2).state == STATE_ON
mock_pymodbus.read_holding_registers.return_value = ReadResult([0x00]) mock_pymodbus.read_holding_registers.return_value = ReadResult([0x00])
await hass.services.async_call( await hass.services.async_call(
"fan", "turn_off", service_data={"entity_id": entity_id2} "fan", "turn_off", service_data={"entity_id": ENTITY_ID2}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id2).state == STATE_OFF assert hass.states.get(ENTITY_ID2).state == STATE_OFF
mock_pymodbus.write_register.side_effect = ModbusException("fail write_") mock_pymodbus.write_register.side_effect = ModbusException("fail write_")
await hass.services.async_call( await hass.services.async_call(
"fan", "turn_on", service_data={"entity_id": entity_id2} "fan", "turn_on", service_data={"entity_id": ENTITY_ID2}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id2).state == STATE_UNAVAILABLE assert hass.states.get(ENTITY_ID2).state == STATE_UNAVAILABLE
mock_pymodbus.write_coil.side_effect = ModbusException("fail write_") mock_pymodbus.write_coil.side_effect = ModbusException("fail write_")
await hass.services.async_call( await hass.services.async_call(
"fan", "turn_off", service_data={"entity_id": entity_id} "fan", "turn_off", service_data={"entity_id": ENTITY_ID}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_UNAVAILABLE assert hass.states.get(ENTITY_ID).state == STATE_UNAVAILABLE
async def test_service_fan_update(hass, mock_pymodbus): async def test_service_fan_update(hass, mock_pymodbus):
@ -279,7 +279,7 @@ async def test_service_fan_update(hass, mock_pymodbus):
config = { config = {
CONF_FANS: [ CONF_FANS: [
{ {
CONF_NAME: fan_name, CONF_NAME: FAN_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_WRITE_TYPE: CALL_TYPE_COIL, CONF_WRITE_TYPE: CALL_TYPE_COIL,
CONF_VERIFY: {}, CONF_VERIFY: {},
@ -292,11 +292,11 @@ async def test_service_fan_update(hass, mock_pymodbus):
config, config,
) )
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == STATE_ON assert hass.states.get(ENTITY_ID).state == STATE_ON
mock_pymodbus.read_coils.return_value = ReadResult([0x00]) mock_pymodbus.read_coils.return_value = ReadResult([0x00])
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == STATE_OFF assert hass.states.get(ENTITY_ID).state == STATE_OFF

70
tests/components/modbus/test_light.py
View File

@ -34,8 +34,8 @@ from homeassistant.setup import async_setup_component
from .conftest import ReadResult, base_test, prepare_service_update from .conftest import ReadResult, base_test, prepare_service_update
light_name = "test_light" LIGHT_NAME = "test_light"
entity_id = f"{LIGHT_DOMAIN}.{light_name}" ENTITY_ID = f"{LIGHT_DOMAIN}.{LIGHT_NAME}"
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -44,7 +44,7 @@ entity_id = f"{LIGHT_DOMAIN}.{light_name}"
{ {
CONF_LIGHTS: [ CONF_LIGHTS: [
{ {
CONF_NAME: light_name, CONF_NAME: LIGHT_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
} }
] ]
@ -52,7 +52,7 @@ entity_id = f"{LIGHT_DOMAIN}.{light_name}"
{ {
CONF_LIGHTS: [ CONF_LIGHTS: [
{ {
CONF_NAME: light_name, CONF_NAME: LIGHT_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_WRITE_TYPE: CALL_TYPE_COIL, CONF_WRITE_TYPE: CALL_TYPE_COIL,
} }
@ -61,7 +61,7 @@ entity_id = f"{LIGHT_DOMAIN}.{light_name}"
{ {
CONF_LIGHTS: [ CONF_LIGHTS: [
{ {
CONF_NAME: light_name, CONF_NAME: LIGHT_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00, CONF_COMMAND_OFF: 0x00,
@ -78,7 +78,7 @@ entity_id = f"{LIGHT_DOMAIN}.{light_name}"
{ {
CONF_LIGHTS: [ CONF_LIGHTS: [
{ {
CONF_NAME: light_name, CONF_NAME: LIGHT_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00, CONF_COMMAND_OFF: 0x00,
@ -95,7 +95,7 @@ entity_id = f"{LIGHT_DOMAIN}.{light_name}"
{ {
CONF_LIGHTS: [ CONF_LIGHTS: [
{ {
CONF_NAME: light_name, CONF_NAME: LIGHT_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00, CONF_COMMAND_OFF: 0x00,
@ -112,7 +112,7 @@ entity_id = f"{LIGHT_DOMAIN}.{light_name}"
{ {
CONF_LIGHTS: [ CONF_LIGHTS: [
{ {
CONF_NAME: light_name, CONF_NAME: LIGHT_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00, CONF_COMMAND_OFF: 0x00,
@ -164,13 +164,13 @@ async def test_all_light(hass, call_type, regs, verify, expected):
state = await base_test( state = await base_test(
hass, hass,
{ {
CONF_NAME: light_name, CONF_NAME: LIGHT_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_WRITE_TYPE: call_type, CONF_WRITE_TYPE: call_type,
**verify, **verify,
}, },
light_name, LIGHT_NAME,
LIGHT_DOMAIN, LIGHT_DOMAIN,
CONF_LIGHTS, CONF_LIGHTS,
None, None,
@ -184,7 +184,7 @@ async def test_all_light(hass, call_type, regs, verify, expected):
@pytest.mark.parametrize( @pytest.mark.parametrize(
"mock_test_state", "mock_test_state",
[(State(entity_id, STATE_ON),)], [(State(ENTITY_ID, STATE_ON),)],
indirect=True, indirect=True,
) )
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -193,7 +193,7 @@ async def test_all_light(hass, call_type, regs, verify, expected):
{ {
CONF_LIGHTS: [ CONF_LIGHTS: [
{ {
CONF_NAME: light_name, CONF_NAME: LIGHT_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
} }
] ]
@ -202,13 +202,13 @@ async def test_all_light(hass, call_type, regs, verify, expected):
) )
async def test_restore_state_light(hass, mock_test_state, mock_modbus): async def test_restore_state_light(hass, mock_test_state, mock_modbus):
"""Run test for sensor restore state.""" """Run test for sensor restore state."""
assert hass.states.get(entity_id).state == mock_test_state[0].state assert hass.states.get(ENTITY_ID).state == mock_test_state[0].state
async def test_light_service_turn(hass, caplog, mock_pymodbus): async def test_light_service_turn(hass, caplog, mock_pymodbus):
"""Run test for service turn_on/turn_off.""" """Run test for service turn_on/turn_off."""
entity_id2 = f"{entity_id}2" ENTITY_ID2 = f"{ENTITY_ID}2"
config = { config = {
MODBUS_DOMAIN: { MODBUS_DOMAIN: {
CONF_TYPE: "tcp", CONF_TYPE: "tcp",
@ -216,12 +216,12 @@ async def test_light_service_turn(hass, caplog, mock_pymodbus):
CONF_PORT: 5501, CONF_PORT: 5501,
CONF_LIGHTS: [ CONF_LIGHTS: [
{ {
CONF_NAME: light_name, CONF_NAME: LIGHT_NAME,
CONF_ADDRESS: 17, CONF_ADDRESS: 17,
CONF_WRITE_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_WRITE_TYPE: CALL_TYPE_REGISTER_HOLDING,
}, },
{ {
CONF_NAME: f"{light_name}2", CONF_NAME: f"{LIGHT_NAME}2",
CONF_ADDRESS: 17, CONF_ADDRESS: 17,
CONF_WRITE_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_WRITE_TYPE: CALL_TYPE_REGISTER_HOLDING,
CONF_VERIFY: {}, CONF_VERIFY: {},
@ -233,44 +233,44 @@ async def test_light_service_turn(hass, caplog, mock_pymodbus):
await hass.async_block_till_done() await hass.async_block_till_done()
assert MODBUS_DOMAIN in hass.config.components assert MODBUS_DOMAIN in hass.config.components
assert hass.states.get(entity_id).state == STATE_OFF assert hass.states.get(ENTITY_ID).state == STATE_OFF
await hass.services.async_call( await hass.services.async_call(
"light", "turn_on", service_data={"entity_id": entity_id} "light", "turn_on", service_data={"entity_id": ENTITY_ID}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_ON assert hass.states.get(ENTITY_ID).state == STATE_ON
await hass.services.async_call( await hass.services.async_call(
"light", "turn_off", service_data={"entity_id": entity_id} "light", "turn_off", service_data={"entity_id": ENTITY_ID}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_OFF assert hass.states.get(ENTITY_ID).state == STATE_OFF
mock_pymodbus.read_holding_registers.return_value = ReadResult([0x01]) mock_pymodbus.read_holding_registers.return_value = ReadResult([0x01])
assert hass.states.get(entity_id2).state == STATE_OFF assert hass.states.get(ENTITY_ID2).state == STATE_OFF
await hass.services.async_call( await hass.services.async_call(
"light", "turn_on", service_data={"entity_id": entity_id2} "light", "turn_on", service_data={"entity_id": ENTITY_ID2}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id2).state == STATE_ON assert hass.states.get(ENTITY_ID2).state == STATE_ON
mock_pymodbus.read_holding_registers.return_value = ReadResult([0x00]) mock_pymodbus.read_holding_registers.return_value = ReadResult([0x00])
await hass.services.async_call( await hass.services.async_call(
"light", "turn_off", service_data={"entity_id": entity_id2} "light", "turn_off", service_data={"entity_id": ENTITY_ID2}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id2).state == STATE_OFF assert hass.states.get(ENTITY_ID2).state == STATE_OFF
mock_pymodbus.write_register.side_effect = ModbusException("fail write_") mock_pymodbus.write_register.side_effect = ModbusException("fail write_")
await hass.services.async_call( await hass.services.async_call(
"light", "turn_on", service_data={"entity_id": entity_id2} "light", "turn_on", service_data={"entity_id": ENTITY_ID2}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id2).state == STATE_UNAVAILABLE assert hass.states.get(ENTITY_ID2).state == STATE_UNAVAILABLE
mock_pymodbus.write_coil.side_effect = ModbusException("fail write_") mock_pymodbus.write_coil.side_effect = ModbusException("fail write_")
await hass.services.async_call( await hass.services.async_call(
"light", "turn_off", service_data={"entity_id": entity_id} "light", "turn_off", service_data={"entity_id": ENTITY_ID}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_UNAVAILABLE assert hass.states.get(ENTITY_ID).state == STATE_UNAVAILABLE
async def test_service_light_update(hass, mock_pymodbus): async def test_service_light_update(hass, mock_pymodbus):
@ -279,7 +279,7 @@ async def test_service_light_update(hass, mock_pymodbus):
config = { config = {
CONF_LIGHTS: [ CONF_LIGHTS: [
{ {
CONF_NAME: light_name, CONF_NAME: LIGHT_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_WRITE_TYPE: CALL_TYPE_COIL, CONF_WRITE_TYPE: CALL_TYPE_COIL,
CONF_VERIFY: {}, CONF_VERIFY: {},
@ -292,11 +292,11 @@ async def test_service_light_update(hass, mock_pymodbus):
config, config,
) )
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == STATE_ON assert hass.states.get(ENTITY_ID).state == STATE_ON
mock_pymodbus.read_coils.return_value = ReadResult([0x00]) mock_pymodbus.read_coils.return_value = ReadResult([0x00])
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == STATE_OFF assert hass.states.get(ENTITY_ID).state == STATE_OFF

54
tests/components/modbus/test_sensor.py
View File

@ -38,8 +38,8 @@ from homeassistant.core import State
from .conftest import ReadResult, base_config_test, base_test, prepare_service_update from .conftest import ReadResult, base_config_test, base_test, prepare_service_update
sensor_name = "test_sensor" SENSOR_NAME = "test_sensor"
entity_id = f"{SENSOR_DOMAIN}.{sensor_name}" ENTITY_ID = f"{SENSOR_DOMAIN}.{SENSOR_NAME}"
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -48,7 +48,7 @@ entity_id = f"{SENSOR_DOMAIN}.{sensor_name}"
{ {
CONF_SENSORS: [ CONF_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 51, CONF_ADDRESS: 51,
} }
] ]
@ -56,7 +56,7 @@ entity_id = f"{SENSOR_DOMAIN}.{sensor_name}"
{ {
CONF_SENSORS: [ CONF_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 51, CONF_ADDRESS: 51,
CONF_SLAVE: 10, CONF_SLAVE: 10,
CONF_COUNT: 1, CONF_COUNT: 1,
@ -72,7 +72,7 @@ entity_id = f"{SENSOR_DOMAIN}.{sensor_name}"
{ {
CONF_SENSORS: [ CONF_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 51, CONF_ADDRESS: 51,
CONF_SLAVE: 10, CONF_SLAVE: 10,
CONF_COUNT: 1, CONF_COUNT: 1,
@ -88,7 +88,7 @@ entity_id = f"{SENSOR_DOMAIN}.{sensor_name}"
{ {
CONF_SENSORS: [ CONF_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 51, CONF_ADDRESS: 51,
CONF_COUNT: 1, CONF_COUNT: 1,
CONF_SWAP: CONF_SWAP_NONE, CONF_SWAP: CONF_SWAP_NONE,
@ -98,7 +98,7 @@ entity_id = f"{SENSOR_DOMAIN}.{sensor_name}"
{ {
CONF_SENSORS: [ CONF_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 51, CONF_ADDRESS: 51,
CONF_COUNT: 1, CONF_COUNT: 1,
CONF_SWAP: CONF_SWAP_BYTE, CONF_SWAP: CONF_SWAP_BYTE,
@ -108,7 +108,7 @@ entity_id = f"{SENSOR_DOMAIN}.{sensor_name}"
{ {
CONF_SENSORS: [ CONF_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 51, CONF_ADDRESS: 51,
CONF_COUNT: 2, CONF_COUNT: 2,
CONF_SWAP: CONF_SWAP_WORD, CONF_SWAP: CONF_SWAP_WORD,
@ -118,7 +118,7 @@ entity_id = f"{SENSOR_DOMAIN}.{sensor_name}"
{ {
CONF_SENSORS: [ CONF_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 51, CONF_ADDRESS: 51,
CONF_COUNT: 2, CONF_COUNT: 2,
CONF_SWAP: CONF_SWAP_WORD_BYTE, CONF_SWAP: CONF_SWAP_WORD_BYTE,
@ -212,7 +212,7 @@ async def test_config_wrong_struct_sensor(
"""Run test for sensor with wrong struct.""" """Run test for sensor with wrong struct."""
config_sensor = { config_sensor = {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
**do_config, **do_config,
} }
caplog.set_level(logging.WARNING) caplog.set_level(logging.WARNING)
@ -221,7 +221,7 @@ async def test_config_wrong_struct_sensor(
await base_config_test( await base_config_test(
hass, hass,
config_sensor, config_sensor,
sensor_name, SENSOR_NAME,
SENSOR_DOMAIN, SENSOR_DOMAIN,
CONF_SENSORS, CONF_SENSORS,
None, None,
@ -507,8 +507,8 @@ async def test_all_sensor(hass, cfg, regs, expected):
state = await base_test( state = await base_test(
hass, hass,
{CONF_NAME: sensor_name, CONF_ADDRESS: 1234, **cfg}, {CONF_NAME: SENSOR_NAME, CONF_ADDRESS: 1234, **cfg},
sensor_name, SENSOR_NAME,
SENSOR_DOMAIN, SENSOR_DOMAIN,
CONF_SENSORS, CONF_SENSORS,
CONF_REGISTERS, CONF_REGISTERS,
@ -561,8 +561,8 @@ async def test_struct_sensor(hass, cfg, regs, expected):
state = await base_test( state = await base_test(
hass, hass,
{CONF_NAME: sensor_name, CONF_ADDRESS: 1234, **cfg}, {CONF_NAME: SENSOR_NAME, CONF_ADDRESS: 1234, **cfg},
sensor_name, SENSOR_NAME,
SENSOR_DOMAIN, SENSOR_DOMAIN,
CONF_SENSORS, CONF_SENSORS,
None, None,
@ -576,7 +576,7 @@ async def test_struct_sensor(hass, cfg, regs, expected):
@pytest.mark.parametrize( @pytest.mark.parametrize(
"mock_test_state", "mock_test_state",
[(State(entity_id, "117"),)], [(State(ENTITY_ID, "117"),)],
indirect=True, indirect=True,
) )
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -585,7 +585,7 @@ async def test_struct_sensor(hass, cfg, regs, expected):
{ {
CONF_SENSORS: [ CONF_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 51, CONF_ADDRESS: 51,
} }
] ]
@ -594,7 +594,7 @@ async def test_struct_sensor(hass, cfg, regs, expected):
) )
async def test_restore_state_sensor(hass, mock_test_state, mock_modbus): async def test_restore_state_sensor(hass, mock_test_state, mock_modbus):
"""Run test for sensor restore state.""" """Run test for sensor restore state."""
assert hass.states.get(entity_id).state == mock_test_state[0].state assert hass.states.get(ENTITY_ID).state == mock_test_state[0].state
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -602,11 +602,11 @@ async def test_restore_state_sensor(hass, mock_test_state, mock_modbus):
[ [
( (
CONF_SWAP_WORD, CONF_SWAP_WORD,
f"Error in sensor {sensor_name} swap(word) not possible due to the registers count: 1, needed: 2", f"Error in sensor {SENSOR_NAME} swap(word) not possible due to the registers count: 1, needed: 2",
), ),
( (
CONF_SWAP_WORD_BYTE, CONF_SWAP_WORD_BYTE,
f"Error in sensor {sensor_name} swap(word_byte) not possible due to the registers count: 1, needed: 2", f"Error in sensor {SENSOR_NAME} swap(word_byte) not possible due to the registers count: 1, needed: 2",
), ),
], ],
) )
@ -615,7 +615,7 @@ async def test_swap_sensor_wrong_config(
): ):
"""Run test for sensor swap.""" """Run test for sensor swap."""
config = { config = {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_COUNT: 1, CONF_COUNT: 1,
CONF_SWAP: swap_type, CONF_SWAP: swap_type,
@ -627,7 +627,7 @@ async def test_swap_sensor_wrong_config(
await base_config_test( await base_config_test(
hass, hass,
config, config,
sensor_name, SENSOR_NAME,
SENSOR_DOMAIN, SENSOR_DOMAIN,
CONF_SENSORS, CONF_SENSORS,
None, None,
@ -642,7 +642,7 @@ async def test_service_sensor_update(hass, mock_pymodbus):
config = { config = {
CONF_SENSORS: [ CONF_SENSORS: [
{ {
CONF_NAME: sensor_name, CONF_NAME: SENSOR_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_INPUT, CONF_INPUT_TYPE: CALL_TYPE_REGISTER_INPUT,
} }
@ -654,11 +654,11 @@ async def test_service_sensor_update(hass, mock_pymodbus):
config, config,
) )
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == "27" assert hass.states.get(ENTITY_ID).state == "27"
mock_pymodbus.read_input_registers.return_value = ReadResult([32]) mock_pymodbus.read_input_registers.return_value = ReadResult([32])
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == "32" assert hass.states.get(ENTITY_ID).state == "32"

78
tests/components/modbus/test_switch.py
View File

@ -43,8 +43,8 @@ from .conftest import ReadResult, base_test, prepare_service_update
from tests.common import async_fire_time_changed from tests.common import async_fire_time_changed
switch_name = "test_switch" SWITCH_NAME = "test_switch"
entity_id = f"{SWITCH_DOMAIN}.{switch_name}" ENTITY_ID = f"{SWITCH_DOMAIN}.{SWITCH_NAME}"
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -53,7 +53,7 @@ entity_id = f"{SWITCH_DOMAIN}.{switch_name}"
{ {
CONF_SWITCHES: [ CONF_SWITCHES: [
{ {
CONF_NAME: switch_name, CONF_NAME: SWITCH_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
} }
] ]
@ -61,7 +61,7 @@ entity_id = f"{SWITCH_DOMAIN}.{switch_name}"
{ {
CONF_SWITCHES: [ CONF_SWITCHES: [
{ {
CONF_NAME: switch_name, CONF_NAME: SWITCH_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_WRITE_TYPE: CALL_TYPE_COIL, CONF_WRITE_TYPE: CALL_TYPE_COIL,
} }
@ -70,7 +70,7 @@ entity_id = f"{SWITCH_DOMAIN}.{switch_name}"
{ {
CONF_SWITCHES: [ CONF_SWITCHES: [
{ {
CONF_NAME: switch_name, CONF_NAME: SWITCH_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00, CONF_COMMAND_OFF: 0x00,
@ -88,7 +88,7 @@ entity_id = f"{SWITCH_DOMAIN}.{switch_name}"
{ {
CONF_SWITCHES: [ CONF_SWITCHES: [
{ {
CONF_NAME: switch_name, CONF_NAME: SWITCH_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00, CONF_COMMAND_OFF: 0x00,
@ -107,7 +107,7 @@ entity_id = f"{SWITCH_DOMAIN}.{switch_name}"
{ {
CONF_SWITCHES: [ CONF_SWITCHES: [
{ {
CONF_NAME: switch_name, CONF_NAME: SWITCH_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00, CONF_COMMAND_OFF: 0x00,
@ -125,7 +125,7 @@ entity_id = f"{SWITCH_DOMAIN}.{switch_name}"
{ {
CONF_SWITCHES: [ CONF_SWITCHES: [
{ {
CONF_NAME: switch_name, CONF_NAME: SWITCH_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00, CONF_COMMAND_OFF: 0x00,
@ -179,13 +179,13 @@ async def test_all_switch(hass, call_type, regs, verify, expected):
state = await base_test( state = await base_test(
hass, hass,
{ {
CONF_NAME: switch_name, CONF_NAME: SWITCH_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_SLAVE: 1, CONF_SLAVE: 1,
CONF_WRITE_TYPE: call_type, CONF_WRITE_TYPE: call_type,
**verify, **verify,
}, },
switch_name, SWITCH_NAME,
SWITCH_DOMAIN, SWITCH_DOMAIN,
CONF_SWITCHES, CONF_SWITCHES,
None, None,
@ -199,7 +199,7 @@ async def test_all_switch(hass, call_type, regs, verify, expected):
@pytest.mark.parametrize( @pytest.mark.parametrize(
"mock_test_state", "mock_test_state",
[(State(entity_id, STATE_ON),)], [(State(ENTITY_ID, STATE_ON),)],
indirect=True, indirect=True,
) )
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -208,7 +208,7 @@ async def test_all_switch(hass, call_type, regs, verify, expected):
{ {
CONF_SWITCHES: [ CONF_SWITCHES: [
{ {
CONF_NAME: switch_name, CONF_NAME: SWITCH_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
} }
] ]
@ -217,13 +217,13 @@ async def test_all_switch(hass, call_type, regs, verify, expected):
) )
async def test_restore_state_switch(hass, mock_test_state, mock_modbus): async def test_restore_state_switch(hass, mock_test_state, mock_modbus):
"""Run test for sensor restore state.""" """Run test for sensor restore state."""
assert hass.states.get(entity_id).state == mock_test_state[0].state assert hass.states.get(ENTITY_ID).state == mock_test_state[0].state
async def test_switch_service_turn(hass, caplog, mock_pymodbus): async def test_switch_service_turn(hass, caplog, mock_pymodbus):
"""Run test for service turn_on/turn_off.""" """Run test for service turn_on/turn_off."""
entity_id2 = f"{SWITCH_DOMAIN}.{switch_name}2" ENTITY_ID2 = f"{SWITCH_DOMAIN}.{SWITCH_NAME}2"
config = { config = {
MODBUS_DOMAIN: { MODBUS_DOMAIN: {
CONF_TYPE: "tcp", CONF_TYPE: "tcp",
@ -231,12 +231,12 @@ async def test_switch_service_turn(hass, caplog, mock_pymodbus):
CONF_PORT: 5501, CONF_PORT: 5501,
CONF_SWITCHES: [ CONF_SWITCHES: [
{ {
CONF_NAME: switch_name, CONF_NAME: SWITCH_NAME,
CONF_ADDRESS: 17, CONF_ADDRESS: 17,
CONF_WRITE_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_WRITE_TYPE: CALL_TYPE_REGISTER_HOLDING,
}, },
{ {
CONF_NAME: f"{switch_name}2", CONF_NAME: f"{SWITCH_NAME}2",
CONF_ADDRESS: 17, CONF_ADDRESS: 17,
CONF_WRITE_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_WRITE_TYPE: CALL_TYPE_REGISTER_HOLDING,
CONF_VERIFY: {}, CONF_VERIFY: {},
@ -248,44 +248,44 @@ async def test_switch_service_turn(hass, caplog, mock_pymodbus):
await hass.async_block_till_done() await hass.async_block_till_done()
assert MODBUS_DOMAIN in hass.config.components assert MODBUS_DOMAIN in hass.config.components
assert hass.states.get(entity_id).state == STATE_OFF assert hass.states.get(ENTITY_ID).state == STATE_OFF
await hass.services.async_call( await hass.services.async_call(
"switch", "turn_on", service_data={"entity_id": entity_id} "switch", "turn_on", service_data={"entity_id": ENTITY_ID}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_ON assert hass.states.get(ENTITY_ID).state == STATE_ON
await hass.services.async_call( await hass.services.async_call(
"switch", "turn_off", service_data={"entity_id": entity_id} "switch", "turn_off", service_data={"entity_id": ENTITY_ID}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_OFF assert hass.states.get(ENTITY_ID).state == STATE_OFF
mock_pymodbus.read_holding_registers.return_value = ReadResult([0x01]) mock_pymodbus.read_holding_registers.return_value = ReadResult([0x01])
assert hass.states.get(entity_id2).state == STATE_OFF assert hass.states.get(ENTITY_ID2).state == STATE_OFF
await hass.services.async_call( await hass.services.async_call(
"switch", "turn_on", service_data={"entity_id": entity_id2} "switch", "turn_on", service_data={"entity_id": ENTITY_ID2}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id2).state == STATE_ON assert hass.states.get(ENTITY_ID2).state == STATE_ON
mock_pymodbus.read_holding_registers.return_value = ReadResult([0x00]) mock_pymodbus.read_holding_registers.return_value = ReadResult([0x00])
await hass.services.async_call( await hass.services.async_call(
"switch", "turn_off", service_data={"entity_id": entity_id2} "switch", "turn_off", service_data={"entity_id": ENTITY_ID2}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id2).state == STATE_OFF assert hass.states.get(ENTITY_ID2).state == STATE_OFF
mock_pymodbus.write_register.side_effect = ModbusException("fail write_") mock_pymodbus.write_register.side_effect = ModbusException("fail write_")
await hass.services.async_call( await hass.services.async_call(
"switch", "turn_on", service_data={"entity_id": entity_id2} "switch", "turn_on", service_data={"entity_id": ENTITY_ID2}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id2).state == STATE_UNAVAILABLE assert hass.states.get(ENTITY_ID2).state == STATE_UNAVAILABLE
mock_pymodbus.write_coil.side_effect = ModbusException("fail write_") mock_pymodbus.write_coil.side_effect = ModbusException("fail write_")
await hass.services.async_call( await hass.services.async_call(
"switch", "turn_off", service_data={"entity_id": entity_id} "switch", "turn_off", service_data={"entity_id": ENTITY_ID}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_UNAVAILABLE assert hass.states.get(ENTITY_ID).state == STATE_UNAVAILABLE
async def test_service_switch_update(hass, mock_pymodbus): async def test_service_switch_update(hass, mock_pymodbus):
@ -294,7 +294,7 @@ async def test_service_switch_update(hass, mock_pymodbus):
config = { config = {
CONF_SWITCHES: [ CONF_SWITCHES: [
{ {
CONF_NAME: switch_name, CONF_NAME: SWITCH_NAME,
CONF_ADDRESS: 1234, CONF_ADDRESS: 1234,
CONF_WRITE_TYPE: CALL_TYPE_COIL, CONF_WRITE_TYPE: CALL_TYPE_COIL,
CONF_VERIFY: {}, CONF_VERIFY: {},
@ -307,14 +307,14 @@ async def test_service_switch_update(hass, mock_pymodbus):
config, config,
) )
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == STATE_ON assert hass.states.get(ENTITY_ID).state == STATE_ON
mock_pymodbus.read_coils.return_value = ReadResult([0x00]) mock_pymodbus.read_coils.return_value = ReadResult([0x00])
await hass.services.async_call( await hass.services.async_call(
"homeassistant", "update_entity", {"entity_id": entity_id}, blocking=True "homeassistant", "update_entity", {"entity_id": ENTITY_ID}, blocking=True
) )
assert hass.states.get(entity_id).state == STATE_OFF assert hass.states.get(ENTITY_ID).state == STATE_OFF
async def test_delay_switch(hass, mock_pymodbus): async def test_delay_switch(hass, mock_pymodbus):
@ -327,7 +327,7 @@ async def test_delay_switch(hass, mock_pymodbus):
CONF_PORT: 5501, CONF_PORT: 5501,
CONF_SWITCHES: [ CONF_SWITCHES: [
{ {
CONF_NAME: switch_name, CONF_NAME: SWITCH_NAME,
CONF_ADDRESS: 51, CONF_ADDRESS: 51,
CONF_SCAN_INTERVAL: 0, CONF_SCAN_INTERVAL: 0,
CONF_VERIFY: { CONF_VERIFY: {
@ -345,12 +345,12 @@ async def test_delay_switch(hass, mock_pymodbus):
assert await async_setup_component(hass, MODBUS_DOMAIN, config) is True assert await async_setup_component(hass, MODBUS_DOMAIN, config) is True
await hass.async_block_till_done() await hass.async_block_till_done()
await hass.services.async_call( await hass.services.async_call(
"switch", "turn_on", service_data={"entity_id": entity_id} "switch", "turn_on", service_data={"entity_id": ENTITY_ID}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_OFF assert hass.states.get(ENTITY_ID).state == STATE_OFF
now = now + timedelta(seconds=2) now = now + timedelta(seconds=2)
with mock.patch("homeassistant.helpers.event.dt_util.utcnow", return_value=now): with mock.patch("homeassistant.helpers.event.dt_util.utcnow", return_value=now):
async_fire_time_changed(hass, now) async_fire_time_changed(hass, now)
await hass.async_block_till_done() await hass.async_block_till_done()
assert hass.states.get(entity_id).state == STATE_ON assert hass.states.get(ENTITY_ID).state == STATE_ON