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

Use test fixture for configuration testing (#51803)

Browse Source 
* Autospec mock_modbus and usei for configuration.

* Review comment.
This commit is contained in:
jan iversen 2021-06-17 12:27:05 +02:00 committed by GitHub
parent 0327d0b6db
commit 08b0ef7a5e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 363 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
tests/components/modbus/conftest.py
View File

@ -40,7 +40,7 @@ def mock_pymodbus():
@pytest.fixture @pytest.fixture
async def mock_modbus(hass, mock_pymodbus): async def mock_modbus(hass, do_config):
"""Load integration modbus using mocked pymodbus.""" """Load integration modbus using mocked pymodbus."""
config = { config = {
DOMAIN: [ DOMAIN: [
@ -49,12 +49,16 @@ async def mock_modbus(hass, mock_pymodbus):
CONF_HOST: "modbusTestHost", CONF_HOST: "modbusTestHost",
CONF_PORT: 5501, CONF_PORT: 5501,
CONF_NAME: TEST_MODBUS_NAME, CONF_NAME: TEST_MODBUS_NAME,
**do_config,
} }
] ]
} }
assert await async_setup_component(hass, DOMAIN, config) is True with mock.patch(
await hass.async_block_till_done() "homeassistant.components.modbus.modbus.ModbusTcpClient", autospec=True
yield mock_pymodbus ) as mock_pb:
assert await async_setup_component(hass, DOMAIN, config) is True
await hass.async_block_till_done()
yield mock_pb
# dataclass # dataclass

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

@ -25,33 +25,32 @@ from tests.common import mock_restore_cache
@pytest.mark.parametrize( @pytest.mark.parametrize(
"do_options", "do_config",
[ [
{},
{ {
CONF_SLAVE: 10, CONF_BINARY_SENSORS: [
CONF_INPUT_TYPE: CALL_TYPE_DISCRETE, {
CONF_DEVICE_CLASS: "door", CONF_NAME: "test_sensor",
CONF_ADDRESS: 51,
}
]
},
{
CONF_BINARY_SENSORS: [
{
CONF_NAME: "test_sensor",
CONF_ADDRESS: 51,
CONF_SLAVE: 10,
CONF_INPUT_TYPE: CALL_TYPE_DISCRETE,
CONF_DEVICE_CLASS: "door",
}
]
}, },
], ],
) )
async def test_config_binary_sensor(hass, do_options): async def test_config_binary_sensor(hass, mock_modbus):
"""Run test for binary sensor.""" """Run config test for binary sensor."""
sensor_name = "test_sensor" assert SENSOR_DOMAIN in hass.config.components
config_sensor = {
CONF_NAME: sensor_name,
CONF_ADDRESS: 51,
**do_options,
}
await base_config_test(
hass,
config_sensor,
sensor_name,
SENSOR_DOMAIN,
CONF_BINARY_SENSORS,
None,
method_discovery=True,
)
@pytest.mark.parametrize("do_type", [CALL_TYPE_COIL, CALL_TYPE_DISCRETE]) @pytest.mark.parametrize("do_type", [CALL_TYPE_COIL, CALL_TYPE_DISCRETE])

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

@ -20,34 +20,35 @@ from tests.common import mock_restore_cache
@pytest.mark.parametrize( @pytest.mark.parametrize(
"do_options", "do_config",
[ [
{},
{ {
CONF_SCAN_INTERVAL: 20, CONF_CLIMATES: [
CONF_COUNT: 2, {
CONF_NAME: "test_climate",
CONF_TARGET_TEMP: 117,
CONF_ADDRESS: 117,
CONF_SLAVE: 10,
}
],
},
{
CONF_CLIMATES: [
{
CONF_NAME: "test_climate",
CONF_TARGET_TEMP: 117,
CONF_ADDRESS: 117,
CONF_SLAVE: 10,
CONF_SCAN_INTERVAL: 20,
CONF_COUNT: 2,
}
],
}, },
], ],
) )
async def test_config_climate(hass, do_options): async def test_config_climate(hass, mock_modbus):
"""Run test for climate.""" """Run configuration test for climate."""
device_name = "test_climate" assert CLIMATE_DOMAIN in hass.config.components
device_config = {
CONF_NAME: device_name,
CONF_TARGET_TEMP: 117,
CONF_ADDRESS: 117,
CONF_SLAVE: 10,
**do_options,
}
await base_config_test(
hass,
device_config,
device_name,
CLIMATE_DOMAIN,
CONF_CLIMATES,
None,
method_discovery=True,
)
@pytest.mark.parametrize( @pytest.mark.parametrize(

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

@ -35,34 +35,33 @@ from tests.common import mock_restore_cache
@pytest.mark.parametrize( @pytest.mark.parametrize(
"do_options", "do_config",
[ [
{},
{ {
CONF_SLAVE: 10, CONF_COVERS: [
CONF_SCAN_INTERVAL: 20, {
CONF_NAME: "test_cover",
CONF_ADDRESS: 1234,
CONF_INPUT_TYPE: CALL_TYPE_COIL,
}
]
},
{
CONF_COVERS: [
{
CONF_NAME: "test_cover",
CONF_ADDRESS: 1234,
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_HOLDING,
CONF_SLAVE: 10,
CONF_SCAN_INTERVAL: 20,
}
]
}, },
], ],
) )
@pytest.mark.parametrize("read_type", [CALL_TYPE_COIL, CALL_TYPE_REGISTER_HOLDING]) async def test_config_cover(hass, mock_modbus):
async def test_config_cover(hass, do_options, read_type): """Run configuration test for cover."""
"""Run test for cover.""" assert COVER_DOMAIN in hass.config.components
device_name = "test_cover"
device_config = {
CONF_NAME: device_name,
CONF_ADDRESS: 1234,
CONF_INPUT_TYPE: read_type,
**do_options,
}
await base_config_test(
hass,
device_config,
device_name,
COVER_DOMAIN,
CONF_COVERS,
None,
method_discovery=True,
)
@pytest.mark.parametrize( @pytest.mark.parametrize(

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

@ -41,75 +41,90 @@ from tests.common import mock_restore_cache
"do_config", "do_config",
[ [
{ {
CONF_ADDRESS: 1234, CONF_FANS: [
{
CONF_NAME: "test_fan",
CONF_ADDRESS: 1234,
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_FANS: [
CONF_WRITE_TYPE: CALL_TYPE_COIL, {
CONF_NAME: "test_fan",
CONF_ADDRESS: 1234,
CONF_WRITE_TYPE: CALL_TYPE_COIL,
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_FANS: [
CONF_SLAVE: 1, {
CONF_COMMAND_OFF: 0x00, CONF_NAME: "test_fan",
CONF_COMMAND_ON: 0x01, CONF_ADDRESS: 1234,
CONF_VERIFY: { CONF_SLAVE: 1,
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_COMMAND_OFF: 0x00,
CONF_ADDRESS: 1235, CONF_COMMAND_ON: 0x01,
CONF_STATE_OFF: 0, CONF_VERIFY: {
CONF_STATE_ON: 1, CONF_INPUT_TYPE: CALL_TYPE_REGISTER_HOLDING,
}, CONF_ADDRESS: 1235,
CONF_STATE_OFF: 0,
CONF_STATE_ON: 1,
},
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_FANS: [
CONF_SLAVE: 1, {
CONF_COMMAND_OFF: 0x00, CONF_NAME: "test_fan",
CONF_COMMAND_ON: 0x01, CONF_ADDRESS: 1234,
CONF_VERIFY: { CONF_SLAVE: 1,
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_INPUT, CONF_COMMAND_OFF: 0x00,
CONF_ADDRESS: 1235, CONF_COMMAND_ON: 0x01,
CONF_STATE_OFF: 0, CONF_VERIFY: {
CONF_STATE_ON: 1, CONF_INPUT_TYPE: CALL_TYPE_REGISTER_INPUT,
}, CONF_ADDRESS: 1235,
CONF_STATE_OFF: 0,
CONF_STATE_ON: 1,
},
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_FANS: [
CONF_SLAVE: 1, {
CONF_COMMAND_OFF: 0x00, CONF_NAME: "test_fan",
CONF_COMMAND_ON: 0x01, CONF_ADDRESS: 1234,
CONF_VERIFY: { CONF_SLAVE: 1,
CONF_INPUT_TYPE: CALL_TYPE_DISCRETE, CONF_COMMAND_OFF: 0x00,
CONF_ADDRESS: 1235, CONF_COMMAND_ON: 0x01,
CONF_STATE_OFF: 0, CONF_VERIFY: {
CONF_STATE_ON: 1, CONF_INPUT_TYPE: CALL_TYPE_DISCRETE,
}, CONF_ADDRESS: 1235,
CONF_STATE_OFF: 0,
CONF_STATE_ON: 1,
},
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_FANS: [
CONF_SLAVE: 1, {
CONF_COMMAND_OFF: 0x00, CONF_NAME: "test_fan",
CONF_COMMAND_ON: 0x01, CONF_ADDRESS: 1234,
CONF_VERIFY: None, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00,
CONF_COMMAND_ON: 0x01,
CONF_VERIFY: None,
}
]
}, },
], ],
) )
async def test_config_fan(hass, do_config): async def test_config_fan(hass, mock_modbus):
"""Run test for fan.""" """Run configuration test for fan."""
device_name = "test_fan" assert FAN_DOMAIN in hass.config.components
device_config = {
CONF_NAME: device_name,
**do_config,
}
await base_config_test(
hass,
device_config,
device_name,
FAN_DOMAIN,
CONF_FANS,
None,
method_discovery=True,
)
@pytest.mark.parametrize("call_type", [CALL_TYPE_COIL, CALL_TYPE_REGISTER_HOLDING]) @pytest.mark.parametrize("call_type", [CALL_TYPE_COIL, CALL_TYPE_REGISTER_HOLDING])

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

@ -41,75 +41,90 @@ from tests.common import mock_restore_cache
"do_config", "do_config",
[ [
{ {
CONF_ADDRESS: 1234, CONF_LIGHTS: [
{
CONF_NAME: "test_light",
CONF_ADDRESS: 1234,
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_LIGHTS: [
CONF_WRITE_TYPE: CALL_TYPE_COIL, {
CONF_NAME: "test_light",
CONF_ADDRESS: 1234,
CONF_WRITE_TYPE: CALL_TYPE_COIL,
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_LIGHTS: [
CONF_SLAVE: 1, {
CONF_COMMAND_OFF: 0x00, CONF_NAME: "test_light",
CONF_COMMAND_ON: 0x01, CONF_ADDRESS: 1234,
CONF_VERIFY: { CONF_SLAVE: 1,
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_COMMAND_OFF: 0x00,
CONF_ADDRESS: 1235, CONF_COMMAND_ON: 0x01,
CONF_STATE_OFF: 0, CONF_VERIFY: {
CONF_STATE_ON: 1, CONF_INPUT_TYPE: CALL_TYPE_REGISTER_HOLDING,
}, CONF_ADDRESS: 1235,
CONF_STATE_OFF: 0,
CONF_STATE_ON: 1,
},
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_LIGHTS: [
CONF_SLAVE: 1, {
CONF_COMMAND_OFF: 0x00, CONF_NAME: "test_light",
CONF_COMMAND_ON: 0x01, CONF_ADDRESS: 1234,
CONF_VERIFY: { CONF_SLAVE: 1,
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_INPUT, CONF_COMMAND_OFF: 0x00,
CONF_ADDRESS: 1235, CONF_COMMAND_ON: 0x01,
CONF_STATE_OFF: 0, CONF_VERIFY: {
CONF_STATE_ON: 1, CONF_INPUT_TYPE: CALL_TYPE_REGISTER_INPUT,
}, CONF_ADDRESS: 1235,
CONF_STATE_OFF: 0,
CONF_STATE_ON: 1,
},
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_LIGHTS: [
CONF_SLAVE: 1, {
CONF_COMMAND_OFF: 0x00, CONF_NAME: "test_light",
CONF_COMMAND_ON: 0x01, CONF_ADDRESS: 1234,
CONF_VERIFY: { CONF_SLAVE: 1,
CONF_INPUT_TYPE: CALL_TYPE_DISCRETE, CONF_COMMAND_OFF: 0x00,
CONF_ADDRESS: 1235, CONF_COMMAND_ON: 0x01,
CONF_STATE_OFF: 0, CONF_VERIFY: {
CONF_STATE_ON: 1, CONF_INPUT_TYPE: CALL_TYPE_DISCRETE,
}, CONF_ADDRESS: 1235,
CONF_STATE_OFF: 0,
CONF_STATE_ON: 1,
},
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_LIGHTS: [
CONF_SLAVE: 1, {
CONF_COMMAND_OFF: 0x00, CONF_NAME: "test_light",
CONF_COMMAND_ON: 0x01, CONF_ADDRESS: 1234,
CONF_VERIFY: None, CONF_SLAVE: 1,
CONF_COMMAND_OFF: 0x00,
CONF_COMMAND_ON: 0x01,
CONF_VERIFY: None,
}
]
}, },
], ],
) )
async def test_config_light(hass, do_config): async def test_config_light(hass, mock_modbus):
"""Run test for light.""" """Run configuration test for light."""
device_name = "test_light" assert LIGHT_DOMAIN in hass.config.components
device_config = {
CONF_NAME: device_name,
**do_config,
}
await base_config_test(
hass,
device_config,
device_name,
LIGHT_DOMAIN,
CONF_LIGHTS,
None,
method_discovery=True,
)
@pytest.mark.parametrize("call_type", [CALL_TYPE_COIL, CALL_TYPE_REGISTER_HOLDING]) @pytest.mark.parametrize("call_type", [CALL_TYPE_COIL, CALL_TYPE_REGISTER_HOLDING])

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

@ -45,68 +45,90 @@ from tests.common import mock_restore_cache
"do_config", "do_config",
[ [
{ {
CONF_ADDRESS: 51, CONF_SENSORS: [
{
CONF_NAME: "test_sensor",
CONF_ADDRESS: 51,
}
]
}, },
{ {
CONF_ADDRESS: 51, CONF_SENSORS: [
CONF_SLAVE: 10, {
CONF_COUNT: 1, CONF_NAME: "test_sensor",
CONF_DATA_TYPE: "int", CONF_ADDRESS: 51,
CONF_PRECISION: 0, CONF_SLAVE: 10,
CONF_SCALE: 1, CONF_COUNT: 1,
CONF_OFFSET: 0, CONF_DATA_TYPE: "int",
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_PRECISION: 0,
CONF_DEVICE_CLASS: "battery", CONF_SCALE: 1,
CONF_OFFSET: 0,
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_HOLDING,
CONF_DEVICE_CLASS: "battery",
}
]
}, },
{ {
CONF_ADDRESS: 51, CONF_SENSORS: [
CONF_SLAVE: 10, {
CONF_COUNT: 1, CONF_NAME: "test_sensor",
CONF_DATA_TYPE: "int", CONF_ADDRESS: 51,
CONF_PRECISION: 0, CONF_SLAVE: 10,
CONF_SCALE: 1, CONF_COUNT: 1,
CONF_OFFSET: 0, CONF_DATA_TYPE: "int",
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_INPUT, CONF_PRECISION: 0,
CONF_DEVICE_CLASS: "battery", CONF_SCALE: 1,
CONF_OFFSET: 0,
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_INPUT,
CONF_DEVICE_CLASS: "battery",
}
]
}, },
{ {
CONF_ADDRESS: 51, CONF_SENSORS: [
CONF_COUNT: 1, {
CONF_SWAP: CONF_SWAP_NONE, CONF_NAME: "test_sensor",
CONF_ADDRESS: 51,
CONF_COUNT: 1,
CONF_SWAP: CONF_SWAP_NONE,
}
]
}, },
{ {
CONF_ADDRESS: 51, CONF_SENSORS: [
CONF_COUNT: 1, {
CONF_SWAP: CONF_SWAP_BYTE, CONF_NAME: "test_sensor",
CONF_ADDRESS: 51,
CONF_COUNT: 1,
CONF_SWAP: CONF_SWAP_BYTE,
}
]
}, },
{ {
CONF_ADDRESS: 51, CONF_SENSORS: [
CONF_COUNT: 2, {
CONF_SWAP: CONF_SWAP_WORD, CONF_NAME: "test_sensor",
CONF_ADDRESS: 51,
CONF_COUNT: 2,
CONF_SWAP: CONF_SWAP_WORD,
}
]
}, },
{ {
CONF_ADDRESS: 51, CONF_SENSORS: [
CONF_COUNT: 2, {
CONF_SWAP: CONF_SWAP_WORD_BYTE, CONF_NAME: "test_sensor",
CONF_ADDRESS: 51,
CONF_COUNT: 2,
CONF_SWAP: CONF_SWAP_WORD_BYTE,
}
]
}, },
], ],
) )
async def test_config_sensor(hass, do_config): async def test_config_sensor(hass, mock_modbus):
"""Run test for sensor.""" """Run configuration test for sensor."""
sensor_name = "test_sensor" assert SENSOR_DOMAIN in hass.config.components
config_sensor = {
CONF_NAME: sensor_name,
**do_config,
}
await base_config_test(
hass,
config_sensor,
sensor_name,
SENSOR_DOMAIN,
CONF_SENSORS,
CONF_REGISTERS,
method_discovery=True,
)
@pytest.mark.parametrize( @pytest.mark.parametrize(

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

@ -48,81 +48,96 @@ from tests.common import async_fire_time_changed, mock_restore_cache
"do_config", "do_config",
[ [
{ {
CONF_ADDRESS: 1234, CONF_SWITCHES: [
{
CONF_NAME: "test_switch",
CONF_ADDRESS: 1234,
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_SWITCHES: [
CONF_WRITE_TYPE: CALL_TYPE_COIL, {
CONF_NAME: "test_switch",
CONF_ADDRESS: 1234,
CONF_WRITE_TYPE: CALL_TYPE_COIL,
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_SWITCHES: [
CONF_SLAVE: 1, {
CONF_COMMAND_OFF: 0x00, CONF_NAME: "test_switch",
CONF_COMMAND_ON: 0x01, CONF_ADDRESS: 1234,
CONF_DEVICE_CLASS: "switch", CONF_SLAVE: 1,
CONF_VERIFY: { CONF_COMMAND_OFF: 0x00,
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_HOLDING, CONF_COMMAND_ON: 0x01,
CONF_ADDRESS: 1235, CONF_DEVICE_CLASS: "switch",
CONF_STATE_OFF: 0, CONF_VERIFY: {
CONF_STATE_ON: 1, CONF_INPUT_TYPE: CALL_TYPE_REGISTER_HOLDING,
}, CONF_ADDRESS: 1235,
CONF_STATE_OFF: 0,
CONF_STATE_ON: 1,
},
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_SWITCHES: [
CONF_SLAVE: 1, {
CONF_COMMAND_OFF: 0x00, CONF_NAME: "test_switch",
CONF_COMMAND_ON: 0x01, CONF_ADDRESS: 1234,
CONF_DEVICE_CLASS: "switch", CONF_SLAVE: 1,
CONF_VERIFY: { CONF_COMMAND_OFF: 0x00,
CONF_INPUT_TYPE: CALL_TYPE_REGISTER_INPUT, CONF_COMMAND_ON: 0x01,
CONF_ADDRESS: 1235, CONF_DEVICE_CLASS: "switch",
CONF_STATE_OFF: 0, CONF_VERIFY: {
CONF_STATE_ON: 1, CONF_INPUT_TYPE: CALL_TYPE_REGISTER_INPUT,
CONF_DELAY: 10, CONF_ADDRESS: 1235,
}, CONF_STATE_OFF: 0,
CONF_STATE_ON: 1,
CONF_DELAY: 10,
},
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_SWITCHES: [
CONF_SLAVE: 1, {
CONF_COMMAND_OFF: 0x00, CONF_NAME: "test_switch",
CONF_COMMAND_ON: 0x01, CONF_ADDRESS: 1234,
CONF_DEVICE_CLASS: "switch", CONF_SLAVE: 1,
CONF_VERIFY: { CONF_COMMAND_OFF: 0x00,
CONF_INPUT_TYPE: CALL_TYPE_DISCRETE, CONF_COMMAND_ON: 0x01,
CONF_ADDRESS: 1235, CONF_DEVICE_CLASS: "switch",
CONF_STATE_OFF: 0, CONF_VERIFY: {
CONF_STATE_ON: 1, CONF_INPUT_TYPE: CALL_TYPE_DISCRETE,
}, CONF_ADDRESS: 1235,
CONF_STATE_OFF: 0,
CONF_STATE_ON: 1,
},
}
]
}, },
{ {
CONF_ADDRESS: 1234, CONF_SWITCHES: [
CONF_SLAVE: 1, {
CONF_COMMAND_OFF: 0x00, CONF_NAME: "test_switch",
CONF_COMMAND_ON: 0x01, CONF_ADDRESS: 1234,
CONF_DEVICE_CLASS: "switch", CONF_SLAVE: 1,
CONF_SCAN_INTERVAL: 0, CONF_COMMAND_OFF: 0x00,
CONF_VERIFY: None, CONF_COMMAND_ON: 0x01,
CONF_DEVICE_CLASS: "switch",
CONF_SCAN_INTERVAL: 0,
CONF_VERIFY: None,
}
]
}, },
], ],
) )
async def test_config_switch(hass, do_config): async def test_config_switch(hass, mock_modbus):
"""Run test for switch.""" """Run configurationtest for switch."""
device_name = "test_switch" assert SWITCH_DOMAIN in hass.config.components
device_config = {
CONF_NAME: device_name,
**do_config,
}
await base_config_test(
hass,
device_config,
device_name,
SWITCH_DOMAIN,
CONF_SWITCHES,
None,
method_discovery=True,
)
@pytest.mark.parametrize("call_type", [CALL_TYPE_COIL, CALL_TYPE_REGISTER_HOLDING]) @pytest.mark.parametrize("call_type", [CALL_TYPE_COIL, CALL_TYPE_REGISTER_HOLDING])