def test_methods(self):
        """ Test if methods call the services as expected. """
        # Test is_on
        self.hass.states.set('light.test', STATE_ON)
        self.assertTrue(light.is_on(self.hass, 'light.test'))

        self.hass.states.set('light.test', STATE_OFF)
        self.assertFalse(light.is_on(self.hass, 'light.test'))

        self.hass.states.set(light.ENTITY_ID_ALL_LIGHTS, STATE_ON)
        self.assertTrue(light.is_on(self.hass))

        self.hass.states.set(light.ENTITY_ID_ALL_LIGHTS, STATE_OFF)
        self.assertFalse(light.is_on(self.hass))

        # Test turn_on
        turn_on_calls = mock_service(
            self.hass, light.DOMAIN, SERVICE_TURN_ON)

        light.turn_on(
            self.hass,
            entity_id='entity_id_val',
            transition='transition_val',
            brightness='brightness_val',
            rgb_color='rgb_color_val',
            xy_color='xy_color_val',
            profile='profile_val')

        self.hass.pool.block_till_done()

        self.assertEqual(1, len(turn_on_calls))
        call = turn_on_calls[-1]

        self.assertEqual(light.DOMAIN, call.domain)
        self.assertEqual(SERVICE_TURN_ON, call.service)
        self.assertEqual('entity_id_val', call.data.get(ATTR_ENTITY_ID))
        self.assertEqual(
            'transition_val', call.data.get(light.ATTR_TRANSITION))
        self.assertEqual(
            'brightness_val', call.data.get(light.ATTR_BRIGHTNESS))
        self.assertEqual('rgb_color_val', call.data.get(light.ATTR_RGB_COLOR))
        self.assertEqual('xy_color_val', call.data.get(light.ATTR_XY_COLOR))
        self.assertEqual('profile_val', call.data.get(light.ATTR_PROFILE))

        # Test turn_off
        turn_off_calls = mock_service(
            self.hass, light.DOMAIN, SERVICE_TURN_OFF)

        light.turn_off(
            self.hass, entity_id='entity_id_val', transition='transition_val')

        self.hass.pool.block_till_done()

        self.assertEqual(1, len(turn_off_calls))
        call = turn_off_calls[-1]

        self.assertEqual(light.DOMAIN, call.domain)
        self.assertEqual(SERVICE_TURN_OFF, call.service)
        self.assertEqual('entity_id_val', call.data[ATTR_ENTITY_ID])
        self.assertEqual('transition_val', call.data[light.ATTR_TRANSITION])
Beispiel #2
0
    def test_deactivated_event(self):
        """Test handling an event from LiteJet."""

        # Initial state is on.

        self.mock_lj.get_load_level.return_value = 99

        self.load_activated_callbacks[ENTITY_OTHER_LIGHT_NUMBER]()
        self.hass.block_till_done()

        assert light.is_on(self.hass, ENTITY_OTHER_LIGHT)

        # Event indicates it is off now.

        self.mock_lj.get_load_level.reset_mock()
        self.mock_lj.get_load_level.return_value = 0

        self.load_deactivated_callbacks[ENTITY_OTHER_LIGHT_NUMBER]()
        self.hass.block_till_done()

        # (Requesting the level is not strictly needed with a deactivated
        # event but the implementation happens to do it. This could be
        # changed to a assert_not_called in the future.)
        self.mock_lj.get_load_level.assert_called_with(
            ENTITY_OTHER_LIGHT_NUMBER)

        assert not light.is_on(self.hass, ENTITY_OTHER_LIGHT)
        assert not light.is_on(self.hass, ENTITY_LIGHT)
        assert self.light().state == 'off'
        assert self.other_light().state == 'off'
Beispiel #3
0
 def test_turn_off(self):
     """Test light turn off method."""
     light.turn_on(self.hass, ENTITY_LIGHT)
     self.hass.block_till_done()
     self.assertTrue(light.is_on(self.hass, ENTITY_LIGHT))
     light.turn_off(self.hass, ENTITY_LIGHT)
     self.hass.block_till_done()
     self.assertFalse(light.is_on(self.hass, ENTITY_LIGHT))
 def test_turn_off_without_entity_id(self):
     """Test light turn off all lights."""
     light.turn_on(self.hass, ENTITY_LIGHT)
     self.hass.block_till_done()
     self.assertTrue(light.is_on(self.hass, ENTITY_LIGHT))
     light.turn_off(self.hass)
     self.hass.block_till_done()
     self.assertFalse(light.is_on(self.hass, ENTITY_LIGHT))
Beispiel #5
0
async def test_turn_off_without_entity_id(hass):
    """Test light turn off all lights."""
    await hass.services.async_call('light', 'turn_on', {
    }, blocking=True)

    assert light.is_on(hass, ENTITY_LIGHT)

    await hass.services.async_call('light', 'turn_off', {
    }, blocking=True)

    assert not light.is_on(hass, ENTITY_LIGHT)
Beispiel #6
0
async def test_turn_off(hass):
    """Test light turn off method."""
    await hass.services.async_call('light', 'turn_on', {
        'entity_id': ENTITY_LIGHT
    }, blocking=True)

    assert light.is_on(hass, ENTITY_LIGHT)

    await hass.services.async_call('light', 'turn_off', {
        'entity_id': ENTITY_LIGHT
    }, blocking=True)

    assert not light.is_on(hass, ENTITY_LIGHT)
Beispiel #7
0
def set_lights_rgb(hass, lights, rgb, transition):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            turn_on(hass, light,
                    rgb_color=rgb,
                    transition=transition)
Beispiel #8
0
async def test_state_attributes(hass):
    """Test light state attributes."""
    common.async_turn_on(
        hass, ENTITY_LIGHT, xy_color=(.4, .4), brightness=25)
    await hass.async_block_till_done()
    state = hass.states.get(ENTITY_LIGHT)
    assert light.is_on(hass, ENTITY_LIGHT)
    assert (0.4, 0.4) == state.attributes.get(light.ATTR_XY_COLOR)
    assert 25 == state.attributes.get(light.ATTR_BRIGHTNESS)
    assert (255, 234, 164) == state.attributes.get(light.ATTR_RGB_COLOR)
    assert 'rainbow' == state.attributes.get(light.ATTR_EFFECT)
    common.async_turn_on(
        hass, ENTITY_LIGHT, rgb_color=(251, 253, 255),
        white_value=254)
    await hass.async_block_till_done()
    state = hass.states.get(ENTITY_LIGHT)
    assert 254 == state.attributes.get(light.ATTR_WHITE_VALUE)
    assert (250, 252, 255) == state.attributes.get(light.ATTR_RGB_COLOR)
    assert (0.319, 0.326) == state.attributes.get(light.ATTR_XY_COLOR)
    common.async_turn_on(hass, ENTITY_LIGHT, color_temp=400, effect='none')
    await hass.async_block_till_done()
    state = hass.states.get(ENTITY_LIGHT)
    assert 400 == state.attributes.get(light.ATTR_COLOR_TEMP)
    assert 153 == state.attributes.get(light.ATTR_MIN_MIREDS)
    assert 500 == state.attributes.get(light.ATTR_MAX_MIREDS)
    assert 'none' == state.attributes.get(light.ATTR_EFFECT)
    common.async_turn_on(hass, ENTITY_LIGHT, kelvin=3000, brightness_pct=50)
    await hass.async_block_till_done()
    state = hass.states.get(ENTITY_LIGHT)
    assert 333 == state.attributes.get(light.ATTR_COLOR_TEMP)
    assert 127 == state.attributes.get(light.ATTR_BRIGHTNESS)
Beispiel #9
0
 def test_state_attributes(self):
     """Test light state attributes."""
     light.turn_on(
         self.hass, ENTITY_LIGHT, xy_color=(.4, .6), brightness=25)
     self.hass.block_till_done()
     state = self.hass.states.get(ENTITY_LIGHT)
     self.assertTrue(light.is_on(self.hass, ENTITY_LIGHT))
     self.assertEqual((.4, .6), state.attributes.get(light.ATTR_XY_COLOR))
     self.assertEqual(25, state.attributes.get(light.ATTR_BRIGHTNESS))
     self.assertEqual(
         (76, 95, 0), state.attributes.get(light.ATTR_RGB_COLOR))
     self.assertEqual('rainbow', state.attributes.get(light.ATTR_EFFECT))
     light.turn_on(
         self.hass, ENTITY_LIGHT, rgb_color=(251, 252, 253),
         white_value=254)
     self.hass.block_till_done()
     state = self.hass.states.get(ENTITY_LIGHT)
     self.assertEqual(254, state.attributes.get(light.ATTR_WHITE_VALUE))
     self.assertEqual(
         (251, 252, 253), state.attributes.get(light.ATTR_RGB_COLOR))
     light.turn_on(self.hass, ENTITY_LIGHT, color_temp=400, effect='none')
     self.hass.block_till_done()
     state = self.hass.states.get(ENTITY_LIGHT)
     self.assertEqual(400, state.attributes.get(light.ATTR_COLOR_TEMP))
     self.assertEqual(154, state.attributes.get(light.ATTR_MIN_MIREDS))
     self.assertEqual(500, state.attributes.get(light.ATTR_MAX_MIREDS))
     self.assertEqual('none', state.attributes.get(light.ATTR_EFFECT))
     light.turn_on(self.hass, ENTITY_LIGHT, kelvin=3000, brightness_pct=50)
     self.hass.block_till_done()
     state = self.hass.states.get(ENTITY_LIGHT)
     self.assertEqual(333, state.attributes.get(light.ATTR_COLOR_TEMP))
     self.assertEqual(127, state.attributes.get(light.ATTR_BRIGHTNESS))
Beispiel #10
0
def set_lights_xy(hass, lights, x_val, y_val, brightness):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            turn_on(hass, light,
                    xy_color=[x_val, y_val],
                    brightness=brightness,
                    transition=30)
Beispiel #11
0
def set_lights_temp(hass, lights, mired, brightness):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            turn_on(hass, light,
                    color_temp=int(mired),
                    brightness=brightness,
                    transition=30)
Beispiel #12
0
 async def _adjust_lights(self, lights, transition):
     if not self._should_adjust():
         return
     tasks = [
         await self._adjust_light(light, transition) for light in lights
         if is_on(self.hass, light)
     ]
     if tasks:
         await asyncio.wait(tasks)
Beispiel #13
0
def set_lights_xy(hass, lights, x_val, y_val, brightness):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            turn_on(hass,
                    light,
                    xy_color=[x_val, y_val],
                    brightness=brightness,
                    transition=30)
Beispiel #14
0
def set_lights_temp(hass, lights, mired, brightness):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            turn_on(hass,
                    light,
                    color_temp=int(mired),
                    brightness=brightness,
                    transition=30)
Beispiel #15
0
def set_lights_temp(hass, lights, kelvin, mode):
    """Set color of array of lights."""
    temp = kelvin
    if mode == MODE_MIRED:
        temp = 1000000 / kelvin
    for light in lights:
        if is_on(hass, light):
            turn_on(hass, light,
                    color_temp=int(temp),
                    transition=30)
Beispiel #16
0
async def test_light_profiles(
    hass, mock_light_profiles, profile_name, expected_data, last_call
):
    """Test light profiles."""
    platform = getattr(hass.components, "test.light")
    platform.init()

    profile_mock_data = {
        "test": (0.4, 0.6, 100, 0),
        "color_no_brightness_no_transition": (0.4, 0.6, None, None),
        "no color": (None, None, 110, 0),
        "test_off": (0, 0, 0, 0),
        "no brightness": (0.4, 0.6, None),
        "color_and_brightness": (0.4, 0.6, 120),
        "color_and_transition": (0.4, 0.6, None, 4.2),
        "brightness_and_transition": (None, None, 130, 5.3),
    }
    for name, data in profile_mock_data.items():
        mock_light_profiles[name] = light.Profile(*(name, *data))

    assert await async_setup_component(
        hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: "test"}}
    )
    await hass.async_block_till_done()

    ent1, _, _ = platform.ENTITIES

    await hass.services.async_call(
        light.DOMAIN,
        SERVICE_TURN_ON,
        {
            ATTR_ENTITY_ID: ent1.entity_id,
            light.ATTR_PROFILE: profile_name,
        },
        blocking=True,
    )

    _, data = ent1.last_call(last_call)
    if last_call == "turn_on":
        assert light.is_on(hass, ent1.entity_id)
    else:
        assert not light.is_on(hass, ent1.entity_id)
    assert data == expected_data
def set_lights_rgb(hass, lights, rgb, transition):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            service_data = {ATTR_ENTITY_ID: light}
            if rgb is not None:
                service_data[ATTR_RGB_COLOR] = rgb
            if transition is not None:
                service_data[ATTR_TRANSITION] = transition
            hass.services.call(LIGHT_DOMAIN, SERVICE_TURN_ON, service_data)
Beispiel #18
0
def set_lights_temp(hass, lights, kelvin, mode):
    """Set color of array of lights."""
    temp = kelvin
    if mode == MODE_MIRED:
        temp = 1000000 / kelvin
    for light in lights:
        if is_on(hass, light):
            turn_on(hass, light,
                    color_temp=int(temp),
                    transition=30)
Beispiel #19
0
 def getlights(key):
     light_ids = []
     for light_id in config[DOMAIN].get(key):
         if hass.states.get(light_id) is None:
             logger.error('Light id %s could not be found in state machine',
                          light_id)
             return []
         if light.is_on(hass, light_id):
             light_ids.append(light_id)
     return light_ids
Beispiel #20
0
async def test_light_profiles(hass, mock_light_profiles):
    """Test light profiles."""
    platform = getattr(hass.components, "test.light")
    platform.init()

    mock_light_profiles["test"] = color.color_xy_to_hs(0.4, 0.6) + (100, 0)
    mock_light_profiles["test_off"] = 0, 0, 0, 0

    assert await async_setup_component(
        hass, light.DOMAIN, {light.DOMAIN: {CONF_PLATFORM: "test"}}
    )
    await hass.async_block_till_done()

    ent1, _, _ = platform.ENTITIES

    await hass.services.async_call(
        light.DOMAIN,
        SERVICE_TURN_ON,
        {
            ATTR_ENTITY_ID: ent1.entity_id,
            light.ATTR_PROFILE: "test",
        },
        blocking=True,
    )

    _, data = ent1.last_call("turn_on")
    assert light.is_on(hass, ent1.entity_id)
    assert data == {
        light.ATTR_HS_COLOR: (71.059, 100),
        light.ATTR_BRIGHTNESS: 100,
        light.ATTR_TRANSITION: 0,
    }

    await hass.services.async_call(
        light.DOMAIN,
        SERVICE_TURN_ON,
        {ATTR_ENTITY_ID: ent1.entity_id, light.ATTR_PROFILE: "test_off"},
        blocking=True,
    )

    _, data = ent1.last_call("turn_off")
    assert not light.is_on(hass, ent1.entity_id)
    assert data == {light.ATTR_TRANSITION: 0}
async def test_config_yaml_alias_anchor(hass, entities, enable_custom_integrations):
    """Test the usage of YAML aliases and anchors.

    The following test scene configuration is equivalent to:

    scene:
      - name: test
        entities:
          light_1: &light_1_state
            state: 'on'
            brightness: 100
          light_2: *light_1_state

    When encountering a YAML alias/anchor, the PyYAML parser will use a
    reference to the original dictionary, instead of creating a copy, so
    care needs to be taken to not modify the original.
    """
    light_1, light_2 = await setup_lights(hass, entities)
    entity_state = {"state": "on", "brightness": 100}

    assert await async_setup_component(
        hass,
        scene.DOMAIN,
        {
            "scene": [
                {
                    "name": "test",
                    "entities": {
                        light_1.entity_id: entity_state,
                        light_2.entity_id: entity_state,
                    },
                }
            ]
        },
    )
    await hass.async_block_till_done()

    await activate(hass, "scene.test")

    assert light.is_on(hass, light_1.entity_id)
    assert light.is_on(hass, light_2.entity_id)
    assert light_1.last_call("turn_on")[1].get("brightness") == 100
    assert light_2.last_call("turn_on")[1].get("brightness") == 100
Beispiel #22
0
    def test_on_brightness(self):
        """Test turning the light on with brightness."""
        assert self.light().state == "off"
        assert self.other_light().state == "off"

        assert not light.is_on(self.hass, ENTITY_LIGHT)

        common.turn_on(self.hass, ENTITY_LIGHT, brightness=102)
        self.hass.block_till_done()
        self.mock_lj.activate_load_at.assert_called_with(ENTITY_LIGHT_NUMBER, 39, 0)
Beispiel #23
0
def set_lights_rgb(hass, lights, rgb, transition, lastcolor):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            states = hass.states.get(light)
            if (lastcolor == 0) or (states.attributes.get('rgb_color') == lastcolor):
                turn_on(hass, light,
                    rgb_color=rgb,
                    transition=transition)
    return rgb
Beispiel #24
0
def set_lights_xy(hass, lights, x_val, y_val, brightness, transition, lastcolor):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            states = hass.states.get(light)
            if (lastcolor == 0) or (states.attributes.get('xy_color') == lastcolor):
                turn_on(hass, light,
                        xy_color=[x_val, y_val],
                        brightness=brightness,
                        transition=transition)
    return [x_val, y_val]
Beispiel #25
0
def set_lights_temp(hass, lights, mired, brightness, transition, lastcolor):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            states = hass.states.get(light)
            if (lastcolor == 0) or (states.attributes.get('color_temp') == lastcolor):
                turn_on(hass, light,
                        color_temp=int(mired),
                        brightness=brightness,
                        transition=transition)
    return int(mired)
Beispiel #26
0
def set_lights_rgb(hass, lights, rgb, transition):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            service_data = {ATTR_ENTITY_ID: light}
            if rgb is not None:
                service_data[ATTR_RGB_COLOR] = rgb
            if transition is not None:
                service_data[ATTR_TRANSITION] = transition
            hass.services.call(
                LIGHT_DOMAIN, SERVICE_TURN_ON, service_data)
Beispiel #27
0
    def test_on_brightness(self):
        """Test turning the light on with brightness."""
        assert self.light().state == 'off'
        assert self.other_light().state == 'off'

        assert not light.is_on(self.hass, ENTITY_LIGHT)

        light.turn_on(self.hass, ENTITY_LIGHT, brightness=102)
        self.hass.block_till_done()
        self.mock_lj.activate_load_at.assert_called_with(
            ENTITY_LIGHT_NUMBER, 39, 0)
Beispiel #28
0
    def test_light_profiles_with_transition(self):
        """Test light profiles with transition."""
        platform = getattr(self.hass.components, "test.light")
        platform.init()

        user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)

        with open(user_light_file, "w") as user_file:
            user_file.write("id,x,y,brightness,transition\n")
            user_file.write("test,.4,.6,100,2\n")
            user_file.write("test_off,0,0,0,0\n")

        assert setup_component(self.hass, light.DOMAIN,
                               {light.DOMAIN: {
                                   CONF_PLATFORM: "test"
                               }})
        self.hass.block_till_done()

        ent1, _, _ = platform.ENTITIES

        common.turn_on(self.hass, ent1.entity_id, profile="test")

        self.hass.block_till_done()

        _, data = ent1.last_call("turn_on")

        assert light.is_on(self.hass, ent1.entity_id)
        assert {
            light.ATTR_HS_COLOR: (71.059, 100),
            light.ATTR_BRIGHTNESS: 100,
            light.ATTR_TRANSITION: 2,
        } == data

        common.turn_on(self.hass, ent1.entity_id, profile="test_off")

        self.hass.block_till_done()

        _, data = ent1.last_call("turn_off")

        assert not light.is_on(self.hass, ent1.entity_id)
        assert {light.ATTR_TRANSITION: 0} == data
def set_lights_temp(hass, lights, mired, brightness, transition):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            service_data = {ATTR_ENTITY_ID: light}
            if mired is not None:
                service_data[ATTR_COLOR_TEMP] = int(mired)
            if brightness is not None:
                service_data[ATTR_BRIGHTNESS] = brightness
            if transition is not None:
                service_data[ATTR_TRANSITION] = transition
            hass.services.call(LIGHT_DOMAIN, SERVICE_TURN_ON, service_data)
Beispiel #30
0
async def test_lights_turn_off_when_everyone_leaves(hass, scanner):
    """Test lights turn off when everyone leaves the house."""
    await common_light.async_turn_on(hass)

    assert await async_setup_component(hass, device_sun_light_trigger.DOMAIN,
                                       {device_sun_light_trigger.DOMAIN: {}})

    hass.states.async_set(device_tracker.ENTITY_ID_ALL_DEVICES, STATE_NOT_HOME)

    await hass.async_block_till_done()

    assert not light.is_on(hass)
Beispiel #31
0
def set_lights_temp(hass, lights, mired, brightness, transition):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            service_data = {ATTR_ENTITY_ID: light}
            if mired is not None:
                service_data[ATTR_COLOR_TEMP] = int(mired)
            if brightness is not None:
                service_data[ATTR_BRIGHTNESS] = brightness
            if transition is not None:
                service_data[ATTR_TRANSITION] = transition
            hass.services.call(
                LIGHT_DOMAIN, SERVICE_TURN_ON, service_data)
Beispiel #32
0
    def test_light_profiles(self):
        """Test light profiles."""
        platform = getattr(self.hass.components, 'test.light')
        platform.init()

        user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE)

        with open(user_light_file, 'w') as user_file:
            user_file.write('id,x,y,brightness\n')
            user_file.write('test,.4,.6,100\n')
            user_file.write('test_off,0,0,0\n')

        assert setup_component(self.hass, light.DOMAIN,
                               {light.DOMAIN: {
                                   CONF_PLATFORM: 'test'
                               }})

        dev1, _, _ = platform.DEVICES

        common.turn_on(self.hass, dev1.entity_id, profile='test')

        self.hass.block_till_done()

        _, data = dev1.last_call('turn_on')

        assert light.is_on(self.hass, dev1.entity_id)
        assert {
            light.ATTR_HS_COLOR: (71.059, 100),
            light.ATTR_BRIGHTNESS: 100
        } == data

        common.turn_on(self.hass, dev1.entity_id, profile='test_off')

        self.hass.block_till_done()

        _, data = dev1.last_call('turn_off')

        assert not light.is_on(self.hass, dev1.entity_id)
        assert {} == data
async def test_activate_scene(hass, entities, enable_custom_integrations):
    """Test active scene."""
    light_1, light_2 = await setup_lights(hass, entities)

    assert await async_setup_component(
        hass,
        scene.DOMAIN,
        {
            "scene": [
                {
                    "name": "test",
                    "entities": {
                        light_1.entity_id: "on",
                        light_2.entity_id: {"state": "on", "brightness": 100},
                    },
                }
            ]
        },
    )
    await hass.async_block_till_done()
    await activate(hass, "scene.test")

    assert light.is_on(hass, light_1.entity_id)
    assert light.is_on(hass, light_2.entity_id)
    assert light_2.last_call("turn_on")[1].get("brightness") == 100

    await turn_off_lights(hass, [light_2.entity_id])

    calls = async_mock_service(hass, "light", "turn_on")

    await hass.services.async_call(
        scene.DOMAIN, "turn_on", {"transition": 42, "entity_id": "scene.test"}
    )
    await hass.async_block_till_done()

    assert len(calls) == 1
    assert calls[0].domain == "light"
    assert calls[0].service == "turn_on"
    assert calls[0].data.get("transition") == 42
async def setup_lights(hass, entities):
    """Set up the light component."""
    assert await async_setup_component(hass, light.DOMAIN,
                                       {light.DOMAIN: {
                                           "platform": "test"
                                       }})
    await hass.async_block_till_done()

    light_1, light_2 = entities

    await hass.services.async_call(
        "light",
        "turn_off",
        {"entity_id": [light_1.entity_id, light_2.entity_id]},
        blocking=True,
    )
    await hass.async_block_till_done()

    assert not light.is_on(hass, light_1.entity_id)
    assert not light.is_on(hass, light_2.entity_id)

    return light_1, light_2
def set_lights_xy(hass, lights, x_val, y_val, brightness, transition):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            service_data = {ATTR_ENTITY_ID: light}
            if x_val is not None and y_val is not None:
                service_data[ATTR_XY_COLOR] = [x_val, y_val]
            if brightness is not None:
                service_data[ATTR_BRIGHTNESS] = brightness
                service_data[ATTR_WHITE_VALUE] = brightness
            if transition is not None:
                service_data[ATTR_TRANSITION] = transition
            hass.services.call(LIGHT_DOMAIN, SERVICE_TURN_ON, service_data)
Beispiel #36
0
async def test_config_yaml_bool(hass, entities, enable_custom_integrations):
    """Test parsing of booleans in yaml config."""
    light_1, light_2 = await setup_lights(hass, entities)

    config = ("scene:\n"
              "  - name: test\n"
              "    entities:\n"
              f"      {light_1.entity_id}: on\n"
              f"      {light_2.entity_id}:\n"
              "        state: on\n"
              "        brightness: 100\n")

    with io.StringIO(config) as file:
        doc = yaml_loader.yaml.safe_load(file)

    assert await async_setup_component(hass, scene.DOMAIN, doc)
    await hass.async_block_till_done()

    await activate(hass, "scene.test")

    assert light.is_on(hass, light_1.entity_id)
    assert light.is_on(hass, light_2.entity_id)
    assert light_2.last_call("turn_on")[1].get("brightness") == 100
Beispiel #37
0
def set_lights_xy(hass, lights, x_val, y_val, brightness, transition):
    """Set color of array of lights."""
    for light in lights:
        if is_on(hass, light):
            service_data = {ATTR_ENTITY_ID: light}
            if x_val is not None and y_val is not None:
                service_data[ATTR_XY_COLOR] = [x_val, y_val]
            if brightness is not None:
                service_data[ATTR_BRIGHTNESS] = brightness
                service_data[ATTR_WHITE_VALUE] = brightness
            if transition is not None:
                service_data[ATTR_TRANSITION] = transition
            hass.services.call(
                LIGHT_DOMAIN, SERVICE_TURN_ON, service_data)
Beispiel #38
0
    def test_on_off(self):
        """Test turning the light on and off."""
        assert self.light().state == 'off'
        assert self.other_light().state == 'off'

        assert not light.is_on(self.hass, ENTITY_LIGHT)

        common.turn_on(self.hass, ENTITY_LIGHT)
        self.hass.block_till_done()
        self.mock_lj.activate_load.assert_called_with(ENTITY_LIGHT_NUMBER)

        common.turn_off(self.hass, ENTITY_LIGHT)
        self.hass.block_till_done()
        self.mock_lj.deactivate_load.assert_called_with(ENTITY_LIGHT_NUMBER)
Beispiel #39
0
    def test_on_off(self):
        """Test turning the light on and off."""
        assert self.light().state == 'off'
        assert self.other_light().state == 'off'

        assert not light.is_on(self.hass, ENTITY_LIGHT)

        light.turn_on(self.hass, ENTITY_LIGHT)
        self.hass.block_till_done()
        self.mock_lj.activate_load.assert_called_with(ENTITY_LIGHT_NUMBER)

        light.turn_off(self.hass, ENTITY_LIGHT)
        self.hass.block_till_done()
        self.mock_lj.deactivate_load.assert_called_with(ENTITY_LIGHT_NUMBER)
Beispiel #40
0
async def test_lights_turn_on_when_coming_home_after_sun_set(hass, scanner):
    """Test lights turn on when coming home after sun set."""
    test_time = datetime(2017, 4, 5, 3, 2, 3, tzinfo=dt_util.UTC)
    with patch("homeassistant.util.dt.utcnow", return_value=test_time):
        await common_light.async_turn_off(hass)

        assert await async_setup_component(
            hass, device_sun_light_trigger.DOMAIN, {device_sun_light_trigger.DOMAIN: {}}
        )

        hass.states.async_set(DT_ENTITY_ID_FORMAT.format("device_2"), STATE_HOME)

        await hass.async_block_till_done()
    assert light.is_on(hass)
    def test_lights_on_when_sun_sets(self):
        """Test lights go on when there is someone home and the sun sets."""
        self.assertTrue(device_sun_light_trigger.setup(
            self.hass, {device_sun_light_trigger.DOMAIN: {}}))

        ensure_sun_risen(self.hass)
        light.turn_off(self.hass)

        self.hass.pool.block_till_done()

        ensure_sun_set(self.hass)
        self.hass.pool.block_till_done()

        self.assertTrue(light.is_on(self.hass))
Beispiel #42
0
    def test_activated_event(self):
        """Test handling an event from LiteJet."""

        self.mock_lj.get_load_level.return_value = 99

        # Light 1

        _LOGGER.info(self.load_activated_callbacks[ENTITY_LIGHT_NUMBER])
        self.load_activated_callbacks[ENTITY_LIGHT_NUMBER]()
        self.hass.block_till_done()

        self.mock_lj.get_load_level.assert_called_once_with(
            ENTITY_LIGHT_NUMBER)

        assert light.is_on(self.hass, ENTITY_LIGHT)
        assert not light.is_on(self.hass, ENTITY_OTHER_LIGHT)
        assert self.light().state == 'on'
        assert self.other_light().state == 'off'
        assert self.light().attributes.get(light.ATTR_BRIGHTNESS) == 255

        # Light 2

        self.mock_lj.get_load_level.return_value = 40

        self.mock_lj.get_load_level.reset_mock()

        self.load_activated_callbacks[ENTITY_OTHER_LIGHT_NUMBER]()
        self.hass.block_till_done()

        self.mock_lj.get_load_level.assert_called_once_with(
            ENTITY_OTHER_LIGHT_NUMBER)

        assert light.is_on(self.hass, ENTITY_OTHER_LIGHT)
        assert light.is_on(self.hass, ENTITY_LIGHT)
        assert self.light().state == 'on'
        assert self.other_light().state == 'on'
        assert int(self.other_light().attributes[light.ATTR_BRIGHTNESS]) == 103
Beispiel #43
0
    def test_activated_event(self):
        """Test handling an event from LiteJet."""

        self.mock_lj.get_load_level.return_value = 99

        # Light 1

        _LOGGER.info(self.load_activated_callbacks[ENTITY_LIGHT_NUMBER])
        self.load_activated_callbacks[ENTITY_LIGHT_NUMBER]()
        self.hass.block_till_done()

        self.mock_lj.get_load_level.assert_called_once_with(
            ENTITY_LIGHT_NUMBER)

        assert light.is_on(self.hass, ENTITY_LIGHT)
        assert not light.is_on(self.hass, ENTITY_OTHER_LIGHT)
        assert self.light().state == 'on'
        assert self.other_light().state == 'off'
        assert self.light().attributes.get(light.ATTR_BRIGHTNESS) == 255

        # Light 2

        self.mock_lj.get_load_level.return_value = 40

        self.mock_lj.get_load_level.reset_mock()

        self.load_activated_callbacks[ENTITY_OTHER_LIGHT_NUMBER]()
        self.hass.block_till_done()

        self.mock_lj.get_load_level.assert_called_once_with(
            ENTITY_OTHER_LIGHT_NUMBER)

        assert light.is_on(self.hass, ENTITY_OTHER_LIGHT)
        assert light.is_on(self.hass, ENTITY_LIGHT)
        assert self.light().state == 'on'
        assert self.other_light().state == 'on'
        assert int(self.other_light().attributes[light.ATTR_BRIGHTNESS]) == 103
Beispiel #44
0
    def test_lights_turn_on_when_coming_home_after_sun_set(self):
        """Test lights turn on when coming home after sun set."""
        test_time = datetime(2017, 4, 5, 3, 2, 3, tzinfo=dt_util.UTC)
        with patch('homeassistant.util.dt.utcnow', return_value=test_time):
            common_light.turn_off(self.hass)
            self.hass.block_till_done()

            assert setup_component(self.hass, device_sun_light_trigger.DOMAIN,
                                   {device_sun_light_trigger.DOMAIN: {}})

            self.hass.states.set(
                device_tracker.ENTITY_ID_FORMAT.format('device_2'), STATE_HOME)

            self.hass.block_till_done()
        assert light.is_on(self.hass)
    def test_lights_turn_off_when_everyone_leaves(self):
        """ Test lights turn off when everyone leaves the house. """
        light.turn_on(self.hass)

        self.hass.pool.block_till_done()

        self.assertTrue(device_sun_light_trigger.setup(
            self.hass, {device_sun_light_trigger.DOMAIN: {}}))

        self.hass.states.set(device_tracker.ENTITY_ID_ALL_DEVICES,
                             STATE_NOT_HOME)

        self.hass.pool.block_till_done()

        self.assertFalse(light.is_on(self.hass))
    def test_lights_turn_on_when_coming_home_after_sun_set(self):
        """Test lights turn on when coming home after sun set."""
        light.turn_off(self.hass)
        ensure_sun_set(self.hass)

        self.hass.pool.block_till_done()

        self.assertTrue(device_sun_light_trigger.setup(
            self.hass, {device_sun_light_trigger.DOMAIN: {}}))

        self.hass.states.set(
            device_tracker.ENTITY_ID_FORMAT.format('device_2'), STATE_HOME)

        self.hass.pool.block_till_done()
        self.assertTrue(light.is_on(self.hass))
    def test_lights_turn_off_when_everyone_leaves(self):
        """Test lights turn off when everyone leaves the house."""
        light.turn_on(self.hass)

        self.hass.pool.block_till_done()

        self.assertTrue(device_sun_light_trigger.setup(
            self.hass, {device_sun_light_trigger.DOMAIN: {}}))

        self.hass.states.set(device_tracker.ENTITY_ID_ALL_DEVICES,
                             STATE_NOT_HOME)

        self.hass.pool.block_till_done()

        self.assertFalse(light.is_on(self.hass))
Beispiel #48
0
async def test_activated_event(hass, mock_litejet):
    """Test handling an event from LiteJet."""

    await async_init_integration(hass)

    # Light 1
    mock_litejet.get_load_level.return_value = 99
    mock_litejet.get_load_level.reset_mock()
    mock_litejet.load_activated_callbacks[ENTITY_LIGHT_NUMBER]()
    await hass.async_block_till_done()

    mock_litejet.get_load_level.assert_called_once_with(ENTITY_LIGHT_NUMBER)

    assert light.is_on(hass, ENTITY_LIGHT)
    assert not light.is_on(hass, ENTITY_OTHER_LIGHT)
    assert hass.states.get(ENTITY_LIGHT).state == "on"
    assert hass.states.get(ENTITY_OTHER_LIGHT).state == "off"
    assert hass.states.get(ENTITY_LIGHT).attributes.get(ATTR_BRIGHTNESS) == 255

    # Light 2

    mock_litejet.get_load_level.return_value = 40
    mock_litejet.get_load_level.reset_mock()
    mock_litejet.load_activated_callbacks[ENTITY_OTHER_LIGHT_NUMBER]()
    await hass.async_block_till_done()

    mock_litejet.get_load_level.assert_called_once_with(
        ENTITY_OTHER_LIGHT_NUMBER)

    assert light.is_on(hass, ENTITY_LIGHT)
    assert light.is_on(hass, ENTITY_OTHER_LIGHT)
    assert hass.states.get(ENTITY_LIGHT).state == "on"
    assert hass.states.get(ENTITY_OTHER_LIGHT).state == "on"
    assert (int(
        hass.states.get(ENTITY_OTHER_LIGHT).attributes.get(ATTR_BRIGHTNESS)) ==
            103)
Beispiel #49
0
    def test_lights_turn_off_when_everyone_leaves(self):
        """Test lights turn off when everyone leaves the house."""
        common_light.turn_on(self.hass)

        self.hass.block_till_done()

        assert setup_component(self.hass, device_sun_light_trigger.DOMAIN,
                               {device_sun_light_trigger.DOMAIN: {}})

        self.hass.states.set(device_tracker.ENTITY_ID_ALL_DEVICES,
                             STATE_NOT_HOME)

        self.hass.block_till_done()

        assert not light.is_on(self.hass)
    def test_lights_turn_on_when_coming_home_after_sun_set(self):
        """Test lights turn on when coming home after sun set."""
        test_time = datetime(2017, 4, 5, 3, 2, 3, tzinfo=dt_util.UTC)
        with patch('homeassistant.util.dt.utcnow', return_value=test_time):
            light.turn_off(self.hass)
            self.hass.block_till_done()

            self.assertTrue(setup_component(
                self.hass, device_sun_light_trigger.DOMAIN, {
                    device_sun_light_trigger.DOMAIN: {}}))

            self.hass.states.set(
                device_tracker.ENTITY_ID_FORMAT.format('device_2'), STATE_HOME)

            self.hass.block_till_done()
        self.assertTrue(light.is_on(self.hass))
Beispiel #51
0
async def test_lights_turn_off_when_everyone_leaves(hass, scanner):
    """Test lights turn off when everyone leaves the house."""
    common_light.async_turn_on(hass)

    await hass.async_block_till_done()

    assert await async_setup_component(
        hass, device_sun_light_trigger.DOMAIN, {
            device_sun_light_trigger.DOMAIN: {}})

    hass.states.async_set(device_tracker.ENTITY_ID_ALL_DEVICES,
                          STATE_NOT_HOME)

    await hass.async_block_till_done()

    assert not light.is_on(hass)
    def test_lights_turn_off_when_everyone_leaves(self):
        """ Test lights turn off when everyone leaves the house. """
        light.turn_on(self.hass)

        self.hass.pool.block_till_done()

        device_sun_light_trigger.setup(
            self.hass, {device_sun_light_trigger.DOMAIN: {}})

        self.scanner.leave_home('DEV1')

        trigger_device_tracker_scan(self.hass)

        self.hass.pool.block_till_done()

        self.assertFalse(light.is_on(self.hass))
Beispiel #53
0
async def test_lights_turn_on_when_coming_home_after_sun_set(hass, scanner):
    """Test lights turn on when coming home after sun set."""
    test_time = datetime(2017, 4, 5, 3, 2, 3, tzinfo=dt_util.UTC)
    with patch('homeassistant.util.dt.utcnow', return_value=test_time):
        common_light.async_turn_off(hass)
        await hass.async_block_till_done()

        assert await async_setup_component(
            hass, device_sun_light_trigger.DOMAIN, {
                device_sun_light_trigger.DOMAIN: {}})

        hass.states.async_set(
            device_tracker.ENTITY_ID_FORMAT.format('device_2'), STATE_HOME)

        await hass.async_block_till_done()
    assert light.is_on(hass)
    def test_lights_turn_on_when_coming_home_after_sun_set(self):
        """ Test lights turn on when coming home after sun set. """
        light.turn_off(self.hass)

        ensure_sun_set(self.hass)

        self.hass.pool.block_till_done()

        device_sun_light_trigger.setup(
            self.hass, {device_sun_light_trigger.DOMAIN: {}})

        self.scanner.come_home('DEV2')
        trigger_device_tracker_scan(self.hass)

        self.hass.pool.block_till_done()

        self.assertTrue(light.is_on(self.hass))
    def test_lights_turn_off_when_everyone_leaves(self): \
            # pylint: disable=invalid-name
        """Test lights turn off when everyone leaves the house."""
        light.turn_on(self.hass)

        self.hass.block_till_done()

        self.assertTrue(setup_component(
            self.hass, device_sun_light_trigger.DOMAIN, {
                device_sun_light_trigger.DOMAIN: {}}))

        self.hass.states.set(device_tracker.ENTITY_ID_ALL_DEVICES,
                             STATE_NOT_HOME)

        self.hass.block_till_done()

        self.assertFalse(light.is_on(self.hass))
    def test_lights_turn_on_when_coming_home_after_sun_set(self):

    # pylint: disable=invalid-name
        """Test lights turn on when coming home after sun set."""
        light.turn_off(self.hass)
        ensure_sun_set(self.hass)

        self.hass.block_till_done()

        self.assertTrue(
            setup_component(self.hass, device_sun_light_trigger.DOMAIN, {device_sun_light_trigger.DOMAIN: {}})
        )

        self.hass.states.set(device_tracker.ENTITY_ID_FORMAT.format("device_2"), STATE_HOME)

        self.hass.block_till_done()
        self.assertTrue(light.is_on(self.hass))
    def test_lights_on_when_sun_sets(self):
        """Test lights go on when there is someone home and the sun sets."""
        test_time = datetime(2017, 4, 5, 1, 2, 3, tzinfo=dt_util.UTC)
        with patch('homeassistant.util.dt.utcnow', return_value=test_time):
            self.assertTrue(setup_component(
                self.hass, device_sun_light_trigger.DOMAIN, {
                    device_sun_light_trigger.DOMAIN: {}}))

        light.turn_off(self.hass)

        self.hass.block_till_done()

        test_time = test_time.replace(hour=3)
        with patch('homeassistant.util.dt.utcnow', return_value=test_time):
            fire_time_changed(self.hass, test_time)
            self.hass.block_till_done()

        self.assertTrue(light.is_on(self.hass))
Beispiel #58
0
async def test_lights_on_when_sun_sets(hass, scanner):
    """Test lights go on when there is someone home and the sun sets."""
    test_time = datetime(2017, 4, 5, 1, 2, 3, tzinfo=dt_util.UTC)
    with patch('homeassistant.util.dt.utcnow', return_value=test_time):
        assert await async_setup_component(
            hass, device_sun_light_trigger.DOMAIN, {
                device_sun_light_trigger.DOMAIN: {}})

    common_light.async_turn_off(hass)

    await hass.async_block_till_done()

    test_time = test_time.replace(hour=3)
    with patch('homeassistant.util.dt.utcnow', return_value=test_time):
        async_fire_time_changed(hass, test_time)
        await hass.async_block_till_done()

    assert light.is_on(hass)