core/tests/components/automation/test_time_pattern.py

"""The tests for the time_pattern automation."""
import pytest

from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util
import homeassistant.components.automation as automation

from tests.common import async_fire_time_changed, mock_component
from tests.components.automation import common
from tests.common import async_mock_service


@pytest.fixture
def calls(hass):
    """Track calls to a mock serivce."""
    return async_mock_service(hass, "test", "automation")


@pytest.fixture(autouse=True)
def setup_comp(hass):
    """Initialize components."""
    mock_component(hass, "group")


async def test_if_fires_when_hour_matches(hass, calls):
    """Test for firing if hour is matching."""
    assert await async_setup_component(
        hass,
        automation.DOMAIN,
        {
            automation.DOMAIN: {
                "trigger": {
                    "platform": "time_pattern",
                    "hours": 0,
                    "minutes": "*",
                    "seconds": "*",
                },
                "action": {"service": "test.automation"},
            }
        },
    )

    async_fire_time_changed(hass, dt_util.utcnow().replace(hour=0))
    await hass.async_block_till_done()
    assert 1 == len(calls)

    await common.async_turn_off(hass)
    await hass.async_block_till_done()

    async_fire_time_changed(hass, dt_util.utcnow().replace(hour=0))
    await hass.async_block_till_done()
    assert 1 == len(calls)


async def test_if_fires_when_minute_matches(hass, calls):
    """Test for firing if minutes are matching."""
    assert await async_setup_component(
        hass,
        automation.DOMAIN,
        {
            automation.DOMAIN: {
                "trigger": {
                    "platform": "time_pattern",
                    "hours": "*",
                    "minutes": 0,
                    "seconds": "*",
                },
                "action": {"service": "test.automation"},
            }
        },
    )

    async_fire_time_changed(hass, dt_util.utcnow().replace(minute=0))

    await hass.async_block_till_done()
    assert 1 == len(calls)


async def test_if_fires_when_second_matches(hass, calls):
    """Test for firing if seconds are matching."""
    assert await async_setup_component(
        hass,
        automation.DOMAIN,
        {
            automation.DOMAIN: {
                "trigger": {
                    "platform": "time_pattern",
                    "hours": "*",
                    "minutes": "*",
                    "seconds": 0,
                },
                "action": {"service": "test.automation"},
            }
        },
    )

    async_fire_time_changed(hass, dt_util.utcnow().replace(second=0))

    await hass.async_block_till_done()
    assert 1 == len(calls)


async def test_if_fires_when_all_matches(hass, calls):
    """Test for firing if everything matches."""
    assert await async_setup_component(
        hass,
        automation.DOMAIN,
        {
            automation.DOMAIN: {
                "trigger": {
                    "platform": "time_pattern",
                    "hours": 1,
                    "minutes": 2,
                    "seconds": 3,
                },
                "action": {"service": "test.automation"},
            }
        },
    )

    async_fire_time_changed(hass, dt_util.utcnow().replace(hour=1, minute=2, second=3))

    await hass.async_block_till_done()
    assert 1 == len(calls)


async def test_if_fires_periodic_seconds(hass, calls):
    """Test for firing periodically every second."""
    assert await async_setup_component(
        hass,
        automation.DOMAIN,
        {
            automation.DOMAIN: {
                "trigger": {
                    "platform": "time_pattern",
                    "hours": "*",
                    "minutes": "*",
                    "seconds": "/2",
                },
                "action": {"service": "test.automation"},
            }
        },
    )

    async_fire_time_changed(hass, dt_util.utcnow().replace(hour=0, minute=0, second=2))

    await hass.async_block_till_done()
    assert 1 == len(calls)


async def test_if_fires_periodic_minutes(hass, calls):
    """Test for firing periodically every minute."""
    assert await async_setup_component(
        hass,
        automation.DOMAIN,
        {
            automation.DOMAIN: {
                "trigger": {
                    "platform": "time_pattern",
                    "hours": "*",
                    "minutes": "/2",
                    "seconds": "*",
                },
                "action": {"service": "test.automation"},
            }
        },
    )

    async_fire_time_changed(hass, dt_util.utcnow().replace(hour=0, minute=2, second=0))

    await hass.async_block_till_done()
    assert 1 == len(calls)


async def test_if_fires_periodic_hours(hass, calls):
    """Test for firing periodically every hour."""
    assert await async_setup_component(
        hass,
        automation.DOMAIN,
        {
            automation.DOMAIN: {
                "trigger": {
                    "platform": "time_pattern",
                    "hours": "/2",
                    "minutes": "*",
                    "seconds": "*",
                },
                "action": {"service": "test.automation"},
            }
        },
    )

    async_fire_time_changed(hass, dt_util.utcnow().replace(hour=2, minute=0, second=0))

    await hass.async_block_till_done()
    assert 1 == len(calls)


async def test_default_values(hass, calls):
    """Test for firing at 2 minutes every hour."""
    assert await async_setup_component(
        hass,
        automation.DOMAIN,
        {
            automation.DOMAIN: {
                "trigger": {"platform": "time_pattern", "minutes": "2"},
                "action": {"service": "test.automation"},
            }
        },
    )

    async_fire_time_changed(hass, dt_util.utcnow().replace(hour=1, minute=2, second=0))

    await hass.async_block_till_done()
    assert 1 == len(calls)

    async_fire_time_changed(hass, dt_util.utcnow().replace(hour=1, minute=2, second=1))

    await hass.async_block_till_done()
    assert 1 == len(calls)

    async_fire_time_changed(hass, dt_util.utcnow().replace(hour=2, minute=2, second=0))

    await hass.async_block_till_done()
    assert 2 == len(calls)