diff --git a/tests/components/template/test_lock.py b/tests/components/template/test_lock.py index 2cbdf23190d..109e4b348b3 100644 --- a/tests/components/template/test_lock.py +++ b/tests/components/template/test_lock.py @@ -5,42 +5,30 @@ from homeassistant import setup from homeassistant.components import lock from homeassistant.const import ATTR_ENTITY_ID, STATE_OFF, STATE_ON, STATE_UNAVAILABLE -from tests.common import assert_setup_component, async_mock_service - -@pytest.fixture -def calls(hass): - """Track calls to a mock service.""" - return async_mock_service(hass, "test", "automation") - - -async def test_template_state(hass): - """Test template.""" - with assert_setup_component(1, lock.DOMAIN): - assert await setup.async_setup_component( - hass, - lock.DOMAIN, - { +@pytest.mark.parametrize("count,domain", [(1, lock.DOMAIN)]) +@pytest.mark.parametrize( + "config", + [ + { + lock.DOMAIN: { + "platform": "template", + "name": "Test template lock", + "value_template": "{{ states.switch.test_state.state }}", "lock": { - "platform": "template", - "name": "Test template lock", - "value_template": "{{ states.switch.test_state.state }}", - "lock": { - "service": "switch.turn_on", - "entity_id": "switch.test_state", - }, - "unlock": { - "service": "switch.turn_off", - "entity_id": "switch.test_state", - }, - } - }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - + "service": "switch.turn_on", + "entity_id": "switch.test_state", + }, + "unlock": { + "service": "switch.turn_off", + "entity_id": "switch.test_state", + }, + } + }, + ], +) +async def test_template_state(hass, start_ha): + """Test template.""" hass.states.async_set("switch.test_state", STATE_ON) await hass.async_block_till_done() @@ -54,196 +42,135 @@ async def test_template_state(hass): assert state.state == lock.STATE_UNLOCKED -async def test_template_state_boolean_on(hass): - """Test the setting of the state with boolean on.""" - with assert_setup_component(1, lock.DOMAIN): - assert await setup.async_setup_component( - hass, - lock.DOMAIN, - { +@pytest.mark.parametrize("count,domain", [(1, lock.DOMAIN)]) +@pytest.mark.parametrize( + "config", + [ + { + lock.DOMAIN: { + "platform": "template", + "value_template": "{{ 1 == 1 }}", "lock": { - "platform": "template", - "value_template": "{{ 1 == 1 }}", - "lock": { - "service": "switch.turn_on", - "entity_id": "switch.test_state", - }, - "unlock": { - "service": "switch.turn_off", - "entity_id": "switch.test_state", - }, - } - }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - + "service": "switch.turn_on", + "entity_id": "switch.test_state", + }, + "unlock": { + "service": "switch.turn_off", + "entity_id": "switch.test_state", + }, + } + }, + ], +) +async def test_template_state_boolean_on(hass, start_ha): + """Test the setting of the state with boolean on.""" state = hass.states.get("lock.template_lock") assert state.state == lock.STATE_LOCKED -async def test_template_state_boolean_off(hass): - """Test the setting of the state with off.""" - with assert_setup_component(1, lock.DOMAIN): - assert await setup.async_setup_component( - hass, - lock.DOMAIN, - { +@pytest.mark.parametrize("count,domain", [(1, lock.DOMAIN)]) +@pytest.mark.parametrize( + "config", + [ + { + lock.DOMAIN: { + "platform": "template", + "value_template": "{{ 1 == 2 }}", "lock": { - "platform": "template", - "value_template": "{{ 1 == 2 }}", - "lock": { - "service": "switch.turn_on", - "entity_id": "switch.test_state", - }, - "unlock": { - "service": "switch.turn_off", - "entity_id": "switch.test_state", - }, - } - }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - + "service": "switch.turn_on", + "entity_id": "switch.test_state", + }, + "unlock": { + "service": "switch.turn_off", + "entity_id": "switch.test_state", + }, + } + }, + ], +) +async def test_template_state_boolean_off(hass, start_ha): + """Test the setting of the state with off.""" state = hass.states.get("lock.template_lock") assert state.state == lock.STATE_UNLOCKED -async def test_template_syntax_error(hass): +@pytest.mark.parametrize("count,domain", [(0, lock.DOMAIN)]) +@pytest.mark.parametrize( + "config", + [ + { + lock.DOMAIN: { + "platform": "template", + "value_template": "{% if rubbish %}", + "lock": { + "service": "switch.turn_on", + "entity_id": "switch.test_state", + }, + "unlock": { + "service": "switch.turn_off", + "entity_id": "switch.test_state", + }, + } + }, + { + "switch": { + "platform": "lock", + "name": "{{%}", + "value_template": "{{ rubbish }", + "lock": { + "service": "switch.turn_on", + "entity_id": "switch.test_state", + }, + "unlock": { + "service": "switch.turn_off", + "entity_id": "switch.test_state", + }, + }, + }, + {lock.DOMAIN: {"platform": "template", "value_template": "Invalid"}}, + { + lock.DOMAIN: { + "platform": "template", + "not_value_template": "{{ states.switch.test_state.state }}", + "lock": { + "service": "switch.turn_on", + "entity_id": "switch.test_state", + }, + "unlock": { + "service": "switch.turn_off", + "entity_id": "switch.test_state", + }, + } + }, + ], +) +async def test_template_syntax_error(hass, start_ha): """Test templating syntax error.""" - with assert_setup_component(0, lock.DOMAIN): - assert await setup.async_setup_component( - hass, - lock.DOMAIN, - { + assert hass.states.async_all() == [] + + +@pytest.mark.parametrize("count,domain", [(1, lock.DOMAIN)]) +@pytest.mark.parametrize( + "config", + [ + { + lock.DOMAIN: { + "platform": "template", + "value_template": "{{ 1 + 1 }}", "lock": { - "platform": "template", - "value_template": "{% if rubbish %}", - "lock": { - "service": "switch.turn_on", - "entity_id": "switch.test_state", - }, - "unlock": { - "service": "switch.turn_off", - "entity_id": "switch.test_state", - }, - } - }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - - assert hass.states.async_all() == [] - - -async def test_invalid_name_does_not_create(hass): - """Test invalid name.""" - with assert_setup_component(0, lock.DOMAIN): - assert await setup.async_setup_component( - hass, - lock.DOMAIN, - { - "switch": { - "platform": "lock", - "name": "{{%}", - "value_template": "{{ rubbish }", - "lock": { - "service": "switch.turn_on", - "entity_id": "switch.test_state", - }, - "unlock": { - "service": "switch.turn_off", - "entity_id": "switch.test_state", - }, - } - }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - - assert hass.states.async_all() == [] - - -async def test_invalid_lock_does_not_create(hass): - """Test invalid lock.""" - with assert_setup_component(0, lock.DOMAIN): - assert await setup.async_setup_component( - hass, - lock.DOMAIN, - {"lock": {"platform": "template", "value_template": "Invalid"}}, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - - assert hass.states.async_all() == [] - - -async def test_missing_template_does_not_create(hass): - """Test missing template.""" - with assert_setup_component(0, lock.DOMAIN): - assert await setup.async_setup_component( - hass, - lock.DOMAIN, - { - "lock": { - "platform": "template", - "not_value_template": "{{ states.switch.test_state.state }}", - "lock": { - "service": "switch.turn_on", - "entity_id": "switch.test_state", - }, - "unlock": { - "service": "switch.turn_off", - "entity_id": "switch.test_state", - }, - } - }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - - assert hass.states.async_all() == [] - - -async def test_template_static(hass, caplog): + "service": "switch.turn_on", + "entity_id": "switch.test_state", + }, + "unlock": { + "service": "switch.turn_off", + "entity_id": "switch.test_state", + }, + } + }, + ], +) +async def test_template_static(hass, start_ha): """Test that we allow static templates.""" - with assert_setup_component(1, lock.DOMAIN): - assert await setup.async_setup_component( - hass, - lock.DOMAIN, - { - "lock": { - "platform": "template", - "value_template": "{{ 1 + 1 }}", - "lock": { - "service": "switch.turn_on", - "entity_id": "switch.test_state", - }, - "unlock": { - "service": "switch.turn_off", - "entity_id": "switch.test_state", - }, - } - }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - state = hass.states.get("lock.template_lock") assert state.state == lock.STATE_UNLOCKED @@ -253,13 +180,12 @@ async def test_template_static(hass, caplog): assert state.state == lock.STATE_LOCKED -async def test_lock_action(hass, calls): - """Test lock action.""" - assert await setup.async_setup_component( - hass, - lock.DOMAIN, +@pytest.mark.parametrize("count,domain", [(1, lock.DOMAIN)]) +@pytest.mark.parametrize( + "config", + [ { - "lock": { + lock.DOMAIN: { "platform": "template", "value_template": "{{ states.switch.test_state.state }}", "lock": {"service": "test.automation"}, @@ -269,12 +195,10 @@ async def test_lock_action(hass, calls): }, } }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - + ], +) +async def test_lock_action(hass, start_ha, calls): + """Test lock action.""" hass.states.async_set("switch.test_state", STATE_OFF) await hass.async_block_till_done() @@ -289,13 +213,12 @@ async def test_lock_action(hass, calls): assert len(calls) == 1 -async def test_unlock_action(hass, calls): - """Test unlock action.""" - assert await setup.async_setup_component( - hass, - lock.DOMAIN, +@pytest.mark.parametrize("count,domain", [(1, lock.DOMAIN)]) +@pytest.mark.parametrize( + "config", + [ { - "lock": { + lock.DOMAIN: { "platform": "template", "value_template": "{{ states.switch.test_state.state }}", "lock": { @@ -305,12 +228,10 @@ async def test_unlock_action(hass, calls): "unlock": {"service": "test.automation"}, } }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - + ], +) +async def test_unlock_action(hass, start_ha, calls): + """Test unlock action.""" hass.states.async_set("switch.test_state", STATE_ON) await hass.async_block_till_done() @@ -325,92 +246,38 @@ async def test_unlock_action(hass, calls): assert len(calls) == 1 -async def test_unlocking(hass, calls): +@pytest.mark.parametrize("count,domain", [(1, lock.DOMAIN)]) +@pytest.mark.parametrize( + "config", + [ + { + lock.DOMAIN: { + "platform": "template", + "value_template": "{{ states.input_select.test_state.state }}", + "lock": {"service": "test.automation"}, + "unlock": {"service": "test.automation"}, + } + }, + ], +) +@pytest.mark.parametrize( + "test_state", [lock.STATE_UNLOCKING, lock.STATE_LOCKING, lock.STATE_JAMMED] +) +async def test_lock_state(hass, test_state, start_ha): """Test unlocking.""" - assert await setup.async_setup_component( - hass, - lock.DOMAIN, - { - "lock": { - "platform": "template", - "value_template": "{{ states.input_select.test_state.state }}", - "lock": {"service": "test.automation"}, - "unlock": {"service": "test.automation"}, - } - }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - - hass.states.async_set("input_select.test_state", lock.STATE_UNLOCKING) + hass.states.async_set("input_select.test_state", test_state) await hass.async_block_till_done() state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_UNLOCKING + assert state.state == test_state -async def test_locking(hass, calls): - """Test unlocking.""" - assert await setup.async_setup_component( - hass, - lock.DOMAIN, +@pytest.mark.parametrize("count,domain", [(1, lock.DOMAIN)]) +@pytest.mark.parametrize( + "config", + [ { - "lock": { - "platform": "template", - "value_template": "{{ states.input_select.test_state.state }}", - "lock": {"service": "test.automation"}, - "unlock": {"service": "test.automation"}, - } - }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - - hass.states.async_set("input_select.test_state", lock.STATE_LOCKING) - await hass.async_block_till_done() - - state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_LOCKING - - -async def test_jammed(hass, calls): - """Test jammed.""" - assert await setup.async_setup_component( - hass, - lock.DOMAIN, - { - "lock": { - "platform": "template", - "value_template": "{{ states.input_select.test_state.state }}", - "lock": {"service": "test.automation"}, - "unlock": {"service": "test.automation"}, - } - }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - - hass.states.async_set("input_select.test_state", lock.STATE_JAMMED) - await hass.async_block_till_done() - - state = hass.states.get("lock.template_lock") - assert state.state == lock.STATE_JAMMED - - -async def test_available_template_with_entities(hass): - """Test availability templates with values from other entities.""" - - await setup.async_setup_component( - hass, - lock.DOMAIN, - { - "lock": { + lock.DOMAIN: { "platform": "template", "value_template": "{{ states('switch.test_state') }}", "lock": {"service": "switch.turn_on", "entity_id": "switch.test_state"}, @@ -421,12 +288,10 @@ async def test_available_template_with_entities(hass): "availability_template": "{{ is_state('availability_state.state', 'on') }}", } }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - + ], +) +async def test_available_template_with_entities(hass, start_ha): + """Test availability templates with values from other entities.""" # When template returns true.. hass.states.async_set("availability_state.state", STATE_ON) await hass.async_block_till_done() @@ -442,13 +307,12 @@ async def test_available_template_with_entities(hass): assert hass.states.get("lock.template_lock").state == STATE_UNAVAILABLE -async def test_invalid_availability_template_keeps_component_available(hass, caplog): - """Test that an invalid availability keeps the device available.""" - await setup.async_setup_component( - hass, - lock.DOMAIN, +@pytest.mark.parametrize("count,domain", [(1, lock.DOMAIN)]) +@pytest.mark.parametrize( + "config", + [ { - "lock": { + lock.DOMAIN: { "platform": "template", "value_template": "{{ 1 + 1 }}", "availability_template": "{{ x - 12 }}", @@ -459,23 +323,22 @@ async def test_invalid_availability_template_keeps_component_available(hass, cap }, } }, - ) - - await hass.async_block_till_done() - await hass.async_start() - await hass.async_block_till_done() - + ], +) +async def test_invalid_availability_template_keeps_component_available( + hass, start_ha, caplog_setup_text +): + """Test that an invalid availability keeps the device available.""" assert hass.states.get("lock.template_lock").state != STATE_UNAVAILABLE - assert ("UndefinedError: 'x' is undefined") in caplog.text + assert ("UndefinedError: 'x' is undefined") in caplog_setup_text -async def test_unique_id(hass): - """Test unique_id option only creates one lock per id.""" - await setup.async_setup_component( - hass, - lock.DOMAIN, +@pytest.mark.parametrize("count,domain", [(1, lock.DOMAIN)]) +@pytest.mark.parametrize( + "config", + [ { - "lock": { + lock.DOMAIN: { "platform": "template", "name": "test_template_lock_01", "unique_id": "not-so-unique-anymore", @@ -485,10 +348,12 @@ async def test_unique_id(hass): "service": "switch.turn_off", "entity_id": "switch.test_state", }, - }, + } }, - ) - + ], +) +async def test_unique_id(hass, start_ha): + """Test unique_id option only creates one lock per id.""" await setup.async_setup_component( hass, lock.DOMAIN,