def test_controlling_state_via_topic_with_templates(self): self.assertTrue(light.setup(self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_light_rgb/status', 'command_topic': 'test_light_rgb/set', 'brightness_state_topic': 'test_light_rgb/brightness/status', 'rgb_state_topic': 'test_light_rgb/rgb/status', 'state_value_template': '{{ value_json.hello }}', 'brightness_value_template': '{{ value_json.hello }}', 'rgb_value_template': '{{ value_json.hello | join(",") }}', } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) self.assertIsNone(state.attributes.get('brightness')) self.assertIsNone(state.attributes.get('rgb_color')) fire_mqtt_message(self.hass, 'test_light_rgb/rgb/status', '{"hello": [1, 2, 3]}') fire_mqtt_message(self.hass, 'test_light_rgb/status', '{"hello": "ON"}') fire_mqtt_message(self.hass, 'test_light_rgb/brightness/status', '{"hello": "50"}') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) self.assertEqual(50, state.attributes.get('brightness')) self.assertEqual([1, 2, 3], state.attributes.get('rgb_color'))
def test_light_profiles(self): """ Test light profiles. """ platform = loader.get_component('light.test') platform.init() user_light_file = self.hass.get_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') self.assertTrue(light.setup( self.hass, {light.DOMAIN: {CONF_PLATFORM: 'test'}} )) dev1, dev2, dev3 = platform.DEVICES light.turn_on(self.hass, dev1.entity_id, profile='test') self.hass.pool.block_till_done() method, data = dev1.last_call('turn_on') self.assertEqual( {light.ATTR_XY_COLOR: [.4, .6], light.ATTR_BRIGHTNESS: 100}, data)
def test_activate_scene(self): test_light = loader.get_component("light.test") test_light.init() self.assertTrue(light.setup(self.hass, {light.DOMAIN: {"platform": "test"}})) light_1, light_2 = test_light.DEVICES[0:2] light.turn_off(self.hass, [light_1.entity_id, light_2.entity_id]) self.hass.pool.block_till_done() self.assertTrue( scene.setup( self.hass, { "scene": [ { "name": "test", "entities": { light_1.entity_id: "on", light_2.entity_id: {"state": "on", "brightness": 100}, }, } ] }, ) ) scene.activate(self.hass, "scene.test") self.hass.pool.block_till_done() self.assertTrue(light_1.is_on) self.assertTrue(light_2.is_on) self.assertEqual(100, light_2.last_call("turn_on")[1].get("brightness"))
def test_sending_mqtt_commands_and_optimistic(self): self.assertTrue(light.setup(self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'command_topic': 'test_light_rgb/set', 'brightness_state_topic': 'test_light_rgb/brightness/status', 'brightness_command_topic': 'test_light_rgb/brightness/set', 'rgb_state_topic': 'test_light_rgb/rgb/status', 'rgb_command_topic': 'test_light_rgb/rgb/set', 'qos': 2, 'payload_on': 'on', 'payload_off': 'off' } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) light.turn_on(self.hass, 'light.test') self.hass.pool.block_till_done() self.assertEqual(('test_light_rgb/set', 'on', 2), self.mock_publish.mock_calls[-1][1]) state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) light.turn_off(self.hass, 'light.test') self.hass.pool.block_till_done() self.assertEqual(('test_light_rgb/set', 'off', 2), self.mock_publish.mock_calls[-1][1]) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state)
def test_flux_before_sunrise(self): """Test the flux switch before sunrise.""" platform = loader.get_component("light.test") platform.init() self.assertTrue(light.setup(self.hass, {light.DOMAIN: {CONF_PLATFORM: "test"}})) dev1 = platform.DEVICES[0] # Verify initial state of light state = self.hass.states.get(dev1.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get("xy_color")) self.assertIsNone(state.attributes.get("brightness")) test_time = dt_util.now().replace(hour=2, minute=30, second=0) sunset_time = test_time.replace(hour=17, minute=0, second=0) sunrise_time = test_time.replace(hour=5, minute=0, second=0) + timedelta(days=1) with patch("homeassistant.util.dt.now", return_value=test_time): with patch("homeassistant.components.sun.next_rising", return_value=sunrise_time): with patch("homeassistant.components.sun.next_setting", return_value=sunset_time): assert setup_component( self.hass, switch.DOMAIN, {switch.DOMAIN: {"platform": "flux", "name": "flux", "lights": [dev1.entity_id]}}, ) turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON) switch.turn_on(self.hass, "switch.flux") self.hass.pool.block_till_done() fire_time_changed(self.hass, test_time) self.hass.pool.block_till_done() call = turn_on_calls[-1] self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 119) self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.591, 0.395])
def test_light_profiles(self): """ Test light profiles. """ platform = loader.get_component('light.test') 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') self.assertTrue( light.setup(self.hass, {light.DOMAIN: { CONF_PLATFORM: 'test' }})) dev1, dev2, dev3 = platform.DEVICES light.turn_on(self.hass, dev1.entity_id, profile='test') self.hass.pool.block_till_done() method, data = dev1.last_call('turn_on') self.assertEqual( { light.ATTR_XY_COLOR: [.4, .6], light.ATTR_BRIGHTNESS: 100 }, data)
def test_activate_scene(self): """Test active scene.""" test_light = loader.get_component('light.test') test_light.init() self.assertTrue(light.setup(self.hass, { light.DOMAIN: {'platform': 'test'} })) light_1, light_2 = test_light.DEVICES[0:2] light.turn_off(self.hass, [light_1.entity_id, light_2.entity_id]) self.hass.pool.block_till_done() self.assertTrue(scene.setup(self.hass, { 'scene': [{ 'name': 'test', 'entities': { light_1.entity_id: 'on', light_2.entity_id: { 'state': 'on', 'brightness': 100, } } }] })) scene.activate(self.hass, 'scene.test') self.hass.pool.block_till_done() self.assertTrue(light_1.is_on) self.assertTrue(light_2.is_on) self.assertEqual(100, light_2.last_call('turn_on')[1].get('brightness'))
def test_flux_when_switch_is_off(self): """Test the flux switch when it is off.""" platform = loader.get_component("light.test") platform.init() self.assertTrue(light.setup(self.hass, {light.DOMAIN: {CONF_PLATFORM: "test"}})) dev1 = platform.DEVICES[0] # Verify initial state of light state = self.hass.states.get(dev1.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get("xy_color")) self.assertIsNone(state.attributes.get("brightness")) test_time = dt_util.now().replace(hour=10, minute=30, second=0) sunset_time = test_time.replace(hour=17, minute=0, second=0) sunrise_time = test_time.replace(hour=5, minute=0, second=0) + timedelta(days=1) with patch("homeassistant.util.dt.now", return_value=test_time): with patch("homeassistant.components.sun.next_rising", return_value=sunrise_time): with patch("homeassistant.components.sun.next_setting", return_value=sunset_time): assert setup_component( self.hass, switch.DOMAIN, {switch.DOMAIN: {"platform": "flux", "name": "flux", "lights": [dev1.entity_id]}}, ) turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON) fire_time_changed(self.hass, test_time) self.hass.pool.block_till_done() self.assertEqual(0, len(turn_on_calls))
def test_activate_scene(self): test_light = loader.get_component('light.test') test_light.init() self.assertTrue(light.setup(self.hass, { light.DOMAIN: {'platform': 'test'} })) light_1, light_2 = test_light.DEVICES[0:2] light.turn_off(self.hass, [light_1.entity_id, light_2.entity_id]) self.hass.pool.block_till_done() self.assertTrue(scene.setup(self.hass, { 'scene': [{ 'name': 'test', 'entities': { light_1.entity_id: 'on', light_2.entity_id: { 'state': 'on', 'brightness': 100, } } }] })) scene.activate(self.hass, 'scene.test') self.hass.pool.block_till_done() self.assertTrue(light_1.is_on) self.assertTrue(light_2.is_on) self.assertEqual(100, light_2.last_call('turn_on')[1].get('brightness'))
def test_show_brightness_if_only_command_topic(self): """Test the brightness if only a command topic is present.""" self.assertTrue( light.setup( self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'brightness_command_topic': 'test_light_rgb/brightness/set', 'command_topic': 'test_light_rgb/set', 'state_topic': 'test_light_rgb/status', } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) self.assertIsNone(state.attributes.get('brightness')) fire_mqtt_message(self.hass, 'test_light_rgb/status', 'ON') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) self.assertEqual(255, state.attributes.get('brightness'))
def test_controlling_state_via_topic(self): self.assertTrue( light.setup( self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_light_rgb/status', 'command_topic': 'test_light_rgb/set', 'brightness_state_topic': 'test_light_rgb/brightness/status', 'brightness_command_topic': 'test_light_rgb/brightness/set', 'rgb_state_topic': 'test_light_rgb/rgb/status', 'rgb_command_topic': 'test_light_rgb/rgb/set', 'qos': 0, 'payload_on': 'on', 'payload_off': 'off' } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) self.assertIsNone(state.attributes.get('rgb_color')) self.assertIsNone(state.attributes.get('brightness')) fire_mqtt_message(self.hass, 'test_light_rgb/status', 'on') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) self.assertEqual([255, 255, 255], state.attributes.get('rgb_color')) self.assertEqual(255, state.attributes.get('brightness')) fire_mqtt_message(self.hass, 'test_light_rgb/status', 'off') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) fire_mqtt_message(self.hass, 'test_light_rgb/status', 'on') self.hass.pool.block_till_done() fire_mqtt_message(self.hass, 'test_light_rgb/brightness/status', '100') self.hass.pool.block_till_done() light_state = self.hass.states.get('light.test') self.hass.pool.block_till_done() self.assertEqual(100, light_state.attributes['brightness']) fire_mqtt_message(self.hass, 'test_light_rgb/status', 'on') self.hass.pool.block_till_done() fire_mqtt_message(self.hass, 'test_light_rgb/rgb/status', '125,125,125') self.hass.pool.block_till_done() light_state = self.hass.states.get('light.test') self.assertEqual([125, 125, 125], light_state.attributes.get('rgb_color'))
def test_no_color_or_brightness_if_no_topics(self): """Test if there is no color and brightness if no topic.""" self.assertTrue( light.setup( self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_light_rgb/status', 'command_topic': 'test_light_rgb/set', } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) self.assertIsNone(state.attributes.get('rgb_color')) self.assertIsNone(state.attributes.get('brightness')) fire_mqtt_message(self.hass, 'test_light_rgb/status', 'ON') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('rgb_color')) self.assertIsNone(state.attributes.get('brightness'))
def test_controlling_state_via_topic_with_templates(self): self.assertTrue(light.setup(self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_light_rgb/status', 'command_topic': 'test_light_rgb/set', 'brightness_state_topic': 'test_light_rgb/brightness/status', 'rgb_state_topic': 'test_light_rgb/rgb/status', 'state_value_template': '{{ value_json.hello }}', 'brightness_value_template': '{{ value_json.hello }}', 'rgb_value_template': '{{ value_json.hello | join(",") }}', } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) self.assertIsNone(state.attributes.get('brightness')) self.assertIsNone(state.attributes.get('rgb_color')) fire_mqtt_message(self.hass, 'test_light_rgb/status', '{"hello": "ON"}') fire_mqtt_message(self.hass, 'test_light_rgb/brightness/status', '{"hello": "50"}') fire_mqtt_message(self.hass, 'test_light_rgb/rgb/status', '{"hello": [1, 2, 3]}') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) self.assertEqual(50, state.attributes.get('brightness')) self.assertEqual([1, 2, 3], state.attributes.get('rgb_color'))
def setUp(self): # pylint: disable=invalid-name self.hass = get_test_home_assistant() self.scanner = loader.get_component('device_tracker.test').get_scanner( None, None) self.scanner.reset() self.scanner.come_home('DEV1') loader.get_component('light.test').init() self.assertTrue( device_tracker.setup( self.hass, {device_tracker.DOMAIN: { CONF_PLATFORM: 'test' }})) self.assertTrue( light.setup(self.hass, {light.DOMAIN: { CONF_PLATFORM: 'test' }})) self.assertTrue( sun.setup(self.hass, {sun.DOMAIN: { sun.CONF_ELEVATION: 0 }}))
def test_controlling_state_via_topic(self): """Test the controlling of the state via topic.""" self.assertTrue(light.setup(self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_light_rgb/status', 'command_topic': 'test_light_rgb/set', 'brightness_state_topic': 'test_light_rgb/brightness/status', 'brightness_command_topic': 'test_light_rgb/brightness/set', 'rgb_state_topic': 'test_light_rgb/rgb/status', 'rgb_command_topic': 'test_light_rgb/rgb/set', 'qos': '0', 'payload_on': 1, 'payload_off': 0 } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) self.assertIsNone(state.attributes.get('rgb_color')) self.assertIsNone(state.attributes.get('brightness')) self.assertIsNone(state.attributes.get(ATTR_ASSUMED_STATE)) fire_mqtt_message(self.hass, 'test_light_rgb/status', '1') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) self.assertEqual([255, 255, 255], state.attributes.get('rgb_color')) self.assertEqual(255, state.attributes.get('brightness')) fire_mqtt_message(self.hass, 'test_light_rgb/status', '0') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) fire_mqtt_message(self.hass, 'test_light_rgb/status', '1') self.hass.pool.block_till_done() fire_mqtt_message(self.hass, 'test_light_rgb/brightness/status', '100') self.hass.pool.block_till_done() light_state = self.hass.states.get('light.test') self.hass.pool.block_till_done() self.assertEqual(100, light_state.attributes['brightness']) fire_mqtt_message(self.hass, 'test_light_rgb/status', '1') self.hass.pool.block_till_done() fire_mqtt_message(self.hass, 'test_light_rgb/rgb/status', '125,125,125') self.hass.pool.block_till_done() light_state = self.hass.states.get('light.test') self.assertEqual([125, 125, 125], light_state.attributes.get('rgb_color'))
def test_sending_mqtt_commands_and_optimistic(self): self.assertTrue( light.setup( self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'command_topic': 'test_light_rgb/set', 'brightness_command_topic': 'test_light_rgb/brightness/set', 'rgb_command_topic': 'test_light_rgb/rgb/set', 'qos': 2, 'payload_on': 'on', 'payload_off': 'off' } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) light.turn_on(self.hass, 'light.test') self.hass.pool.block_till_done() self.assertEqual(('test_light_rgb/set', 'on', 2, False), self.mock_publish.mock_calls[-1][1]) state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) light.turn_off(self.hass, 'light.test') self.hass.pool.block_till_done() self.assertEqual(('test_light_rgb/set', 'off', 2, False), self.mock_publish.mock_calls[-1][1]) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) light.turn_on(self.hass, 'light.test', rgb_color=[75, 75, 75], brightness=50) self.hass.pool.block_till_done() # Calls are threaded so we need to reorder them bright_call, rgb_call, state_call = \ sorted((call[1] for call in self.mock_publish.mock_calls[-3:]), key=lambda call: call[0]) self.assertEqual(('test_light_rgb/set', 'on', 2, False), state_call) self.assertEqual(('test_light_rgb/rgb/set', '75,75,75', 2, False), rgb_call) self.assertEqual(('test_light_rgb/brightness/set', 50, 2, False), bright_call) state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) self.assertEqual([75, 75, 75], state.attributes['rgb_color']) self.assertEqual(50, state.attributes['brightness'])
def test_fail_setup_if_no_command_topic(self): self.assertTrue(light.setup(self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', } })) self.assertIsNone(self.hass.states.get('light.test'))
def test_fail_setup_if_no_command_topic(self): self.assertTrue(light.setup(self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', } })) self.assertIsNone(self.hass.states.get('light.test'))
def test_sending_mqtt_commands_and_optimistic(self): """Test the sending of command in optimistic mode.""" self.assertTrue(light.setup(self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'command_topic': 'test_light_rgb/set', 'brightness_command_topic': 'test_light_rgb/brightness/set', 'rgb_command_topic': 'test_light_rgb/rgb/set', 'qos': 2, 'payload_on': 'on', 'payload_off': 'off' } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE)) light.turn_on(self.hass, 'light.test') self.hass.pool.block_till_done() self.assertEqual(('test_light_rgb/set', 'on', 2, False), self.mock_publish.mock_calls[-1][1]) state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) light.turn_off(self.hass, 'light.test') self.hass.pool.block_till_done() self.assertEqual(('test_light_rgb/set', 'off', 2, False), self.mock_publish.mock_calls[-1][1]) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) light.turn_on(self.hass, 'light.test', rgb_color=[75, 75, 75], brightness=50) self.hass.pool.block_till_done() # Calls are threaded so we need to reorder them bright_call, rgb_call, state_call = \ sorted((call[1] for call in self.mock_publish.mock_calls[-3:]), key=lambda call: call[0]) self.assertEqual(('test_light_rgb/set', 'on', 2, False), state_call) self.assertEqual(('test_light_rgb/rgb/set', '75,75,75', 2, False), rgb_call) self.assertEqual(('test_light_rgb/brightness/set', 50, 2, False), bright_call) state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) self.assertEqual([75, 75, 75], state.attributes['rgb_color']) self.assertEqual(50, state.attributes['brightness'])
def test_config_yaml_alias_anchor(self): """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. """ test_light = loader.get_component('light.test') test_light.init() self.assertTrue( light.setup(self.hass, {light.DOMAIN: { 'platform': 'test' }})) light_1, light_2 = test_light.DEVICES[0:2] light.turn_off(self.hass, [light_1.entity_id, light_2.entity_id]) self.hass.pool.block_till_done() entity_state = { 'state': 'on', 'brightness': 100, } self.assertTrue( scene.setup( self.hass, { 'scene': [{ 'name': 'test', 'entities': { light_1.entity_id: entity_state, light_2.entity_id: entity_state, } }] })) scene.activate(self.hass, 'scene.test') self.hass.pool.block_till_done() self.assertTrue(light_1.is_on) self.assertTrue(light_2.is_on) self.assertEqual(100, light_1.last_call('turn_on')[1].get('brightness')) self.assertEqual(100, light_2.last_call('turn_on')[1].get('brightness'))
def setUp(self): # pylint: disable=invalid-name self.hass = get_test_home_assistant() self.scanner = loader.get_component( 'device_tracker.test').get_scanner(None, None) self.scanner.reset() self.scanner.come_home('DEV1') loader.get_component('light.test').init() device_tracker.setup(self.hass, { device_tracker.DOMAIN: {CONF_PLATFORM: 'test'} }) light.setup(self.hass, { light.DOMAIN: {CONF_PLATFORM: 'test'} }) sun.setup(self.hass, {})
def test_setup(self): """ Test the setup method. """ # Bogus config self.assertFalse(light.setup(self.hass, {})) self.assertFalse(light.setup(self.hass, {light.DOMAIN: {}})) # Test with non-existing component self.assertFalse(light.setup( self.hass, {light.DOMAIN: {ha.CONF_TYPE: 'nonexisting'}} )) # Test if light component returns 0 lightes mock_toggledevice_platform.init(True) self.assertEqual( [], mock_toggledevice_platform.get_lights(None, None)) self.assertFalse(light.setup( self.hass, {light.DOMAIN: {ha.CONF_TYPE: 'test'}} ))
def test_config_yaml_alias_anchor(self): """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. """ test_light = loader.get_component('light.test') test_light.init() self.assertTrue(light.setup(self.hass, { light.DOMAIN: {'platform': 'test'} })) light_1, light_2 = test_light.DEVICES[0:2] light.turn_off(self.hass, [light_1.entity_id, light_2.entity_id]) self.hass.pool.block_till_done() entity_state = { 'state': 'on', 'brightness': 100, } self.assertTrue(scene.setup(self.hass, { 'scene': [{ 'name': 'test', 'entities': { light_1.entity_id: entity_state, light_2.entity_id: entity_state, } }] })) scene.activate(self.hass, 'scene.test') self.hass.pool.block_till_done() self.assertTrue(light_1.is_on) self.assertTrue(light_2.is_on) self.assertEqual(100, light_1.last_call('turn_on')[1].get('brightness')) self.assertEqual(100, light_2.last_call('turn_on')[1].get('brightness'))
def test_controlling_state_via_topic(self): self.assertTrue(light.setup(self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_light_rgb/status', 'command_topic': 'test_light_rgb/set', 'brightness_state_topic': 'test_light_rgb/brightness/status', 'brightness_command_topic': 'test_light_rgb/brightness/set', 'rgb_state_topic': 'test_light_rgb/rgb/status', 'rgb_command_topic': 'test_light_rgb/rgb/set', 'qos': 0, 'payload_on': 'on', 'payload_off': 'off' } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) fire_mqtt_message(self.hass, 'test_light_rgb/status', 'on') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) fire_mqtt_message(self.hass, 'test_light_rgb/status', 'off') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) fire_mqtt_message(self.hass, 'test_light_rgb/status', 'on') self.hass.pool.block_till_done() fire_mqtt_message(self.hass, 'test_light_rgb/brightness/status', '100') self.hass.pool.block_till_done() light_state = self.hass.states.get('light.test') self.hass.pool.block_till_done() self.assertEqual(100, light_state.attributes['brightness']) fire_mqtt_message(self.hass, 'test_light_rgb/status', 'on') self.hass.pool.block_till_done() fire_mqtt_message(self.hass, 'test_light_rgb/rgb/status', '125,125,125') self.hass.pool.block_till_done() light_state = self.hass.states.get('light.test') self.assertEqual([125, 125, 125], light_state.attributes.get('rgb_color'))
def test_setup(self): """ Test the setup method. """ # Bogus config self.assertFalse(light.setup(self.hass, {})) self.assertFalse(light.setup(self.hass, {light.DOMAIN: {}})) # Test with non-existing component self.assertFalse(light.setup( self.hass, {light.DOMAIN: {CONF_TYPE: 'nonexisting'}} )) # Test if light component returns 0 lightes platform = loader.get_component('light.test') platform.init(True) self.assertEqual([], platform.get_lights(None, None)) self.assertFalse(light.setup( self.hass, {light.DOMAIN: {CONF_TYPE: 'test'}} ))
def test_broken_light_profiles(self): """ Test light profiles. """ platform = loader.get_component("light.test") platform.init() user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE) # Setup a wrong light file with open(user_light_file, "w") as user_file: user_file.write("id,x,y,brightness\n") user_file.write("I,WILL,NOT,WORK\n") self.assertFalse(light.setup(self.hass, {light.DOMAIN: {CONF_PLATFORM: "test"}}))
def test_light_profiles(self): """ Test light profiles. """ platform = loader.get_component('light.test') platform.init() user_light_file = self.hass.get_config_path(light.LIGHT_PROFILES_FILE) # Setup a wrong light file with open(user_light_file, 'w') as user_file: user_file.write('id,x,y,brightness\n') user_file.write('I,WILL,NOT,WORK\n') self.assertFalse(light.setup( self.hass, {light.DOMAIN: {CONF_TYPE: 'test'}} )) # Clean up broken file os.remove(user_light_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') self.assertTrue(light.setup( self.hass, {light.DOMAIN: {CONF_TYPE: 'test'}} )) dev1, dev2, dev3 = platform.get_lights(None, None) light.turn_on(self.hass, dev1.entity_id, profile='test') self.hass._pool.block_till_done() method, data = dev1.last_call('turn_on') self.assertEqual( {light.ATTR_XY_COLOR: [.4, .6], light.ATTR_BRIGHTNESS: 100}, data)
def test_light_profiles(self): """ Test light profiles. """ mock_toggledevice_platform.init() user_light_file = self.hass.get_config_path(light.LIGHT_PROFILES_FILE) # Setup a wrong light file with open(user_light_file, 'w') as user_file: user_file.write('id,x,y,brightness\n') user_file.write('I,WILL,NOT,WORK\n') self.assertFalse(light.setup( self.hass, {light.DOMAIN: {ha.CONF_TYPE: 'test'}} )) # Clean up broken file os.remove(user_light_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') self.assertTrue(light.setup( self.hass, {light.DOMAIN: {ha.CONF_TYPE: 'test'}} )) dev1, dev2, dev3 = mock_toggledevice_platform.get_lights(None, None) light.turn_on(self.hass, dev1.entity_id, profile='test') self.hass._pool.block_till_done() method, data = dev1.last_call('turn_on') self.assertEqual( {light.ATTR_XY_COLOR: [.4, .6], light.ATTR_BRIGHTNESS: 100}, data)
def test_broken_light_profiles(self): """Test light profiles.""" platform = loader.get_component('light.test') platform.init() user_light_file = self.hass.config.path(light.LIGHT_PROFILES_FILE) # Setup a wrong light file with open(user_light_file, 'w') as user_file: user_file.write('id,x,y,brightness\n') user_file.write('I,WILL,NOT,WORK\n') self.assertFalse(light.setup( self.hass, {light.DOMAIN: {CONF_PLATFORM: 'test'}} ))
def test_broken_light_profiles(self): """ Test light profiles. """ platform = loader.get_component('light.test') platform.init() user_light_file = self.hass.get_config_path(light.LIGHT_PROFILES_FILE) # Setup a wrong light file with open(user_light_file, 'w') as user_file: user_file.write('id,x,y,brightness\n') user_file.write('I,WILL,NOT,WORK\n') self.assertFalse(light.setup( self.hass, {light.DOMAIN: {CONF_TYPE: 'test'}} ))
def test_controlling_scale(self): """Test the controlling scale.""" self.assertTrue( light.setup( self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_scale/status', 'command_topic': 'test_scale/set', 'brightness_state_topic': 'test_scale/brightness/status', 'brightness_command_topic': 'test_scale/brightness/set', 'brightness_scale': '99', 'qos': 0, 'payload_on': 'on', 'payload_off': 'off' } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) self.assertIsNone(state.attributes.get('brightness')) self.assertIsNone(state.attributes.get(ATTR_ASSUMED_STATE)) fire_mqtt_message(self.hass, 'test_scale/status', 'on') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) self.assertEqual(255, state.attributes.get('brightness')) fire_mqtt_message(self.hass, 'test_scale/status', 'off') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) fire_mqtt_message(self.hass, 'test_scale/status', 'on') self.hass.pool.block_till_done() fire_mqtt_message(self.hass, 'test_scale/brightness/status', '99') self.hass.pool.block_till_done() light_state = self.hass.states.get('light.test') self.hass.pool.block_till_done() self.assertEqual(255, light_state.attributes['brightness'])
def test_flux_with_custom_colortemps(self): """Test the flux with custom start and stop colortemps.""" platform = loader.get_component('light.test') platform.init() self.assertTrue( light.setup(self.hass, {light.DOMAIN: { CONF_PLATFORM: 'test' }})) dev1 = platform.DEVICES[0] # Verify initial state of light state = self.hass.states.get(dev1.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('xy_color')) self.assertIsNone(state.attributes.get('brightness')) test_time = dt_util.now().replace(hour=17, minute=30, second=0) sunset_time = test_time.replace(hour=17, minute=0, second=0) sunrise_time = test_time.replace(hour=5, minute=0, second=0) + timedelta(days=1) with patch('homeassistant.util.dt.now', return_value=test_time): with patch('homeassistant.components.sun.next_rising', return_value=sunrise_time): with patch('homeassistant.components.sun.next_setting', return_value=sunset_time): assert setup_component( self.hass, switch.DOMAIN, { switch.DOMAIN: { 'platform': 'flux', 'name': 'flux', 'lights': [dev1.entity_id], 'start_colortemp': '1000', 'stop_colortemp': '6000' } }) turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON) switch.turn_on(self.hass, 'switch.flux') self.hass.pool.block_till_done() fire_time_changed(self.hass, test_time) self.hass.pool.block_till_done() call = turn_on_calls[-1] self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 167) self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.461, 0.389])
def test_controlling_scale(self): """Test the controlling scale.""" self.assertTrue(light.setup(self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_scale/status', 'command_topic': 'test_scale/set', 'brightness_state_topic': 'test_scale/brightness/status', 'brightness_command_topic': 'test_scale/brightness/set', 'brightness_scale': '99', 'qos': 0, 'payload_on': 'on', 'payload_off': 'off' } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) self.assertIsNone(state.attributes.get('brightness')) self.assertIsNone(state.attributes.get(ATTR_ASSUMED_STATE)) fire_mqtt_message(self.hass, 'test_scale/status', 'on') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) self.assertEqual(255, state.attributes.get('brightness')) fire_mqtt_message(self.hass, 'test_scale/status', 'off') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) fire_mqtt_message(self.hass, 'test_scale/status', 'on') self.hass.pool.block_till_done() fire_mqtt_message(self.hass, 'test_scale/brightness/status', '99') self.hass.pool.block_till_done() light_state = self.hass.states.get('light.test') self.hass.pool.block_till_done() self.assertEqual(255, light_state.attributes['brightness'])
def test_flux_with_custom_colortemps(self): """Test the flux with custom start and stop colortemps.""" platform = loader.get_component('light.test') platform.init() self.assertTrue( light.setup(self.hass, {light.DOMAIN: {CONF_PLATFORM: 'test'}})) dev1 = platform.DEVICES[0] # Verify initial state of light state = self.hass.states.get(dev1.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('xy_color')) self.assertIsNone(state.attributes.get('brightness')) test_time = dt_util.now().replace(hour=17, minute=30, second=0) sunset_time = test_time.replace(hour=17, minute=0, second=0) sunrise_time = test_time.replace(hour=5, minute=0, second=0) + timedelta(days=1) with patch('homeassistant.util.dt.now', return_value=test_time): with patch('homeassistant.components.sun.next_rising', return_value=sunrise_time): with patch('homeassistant.components.sun.next_setting', return_value=sunset_time): assert setup_component(self.hass, switch.DOMAIN, { switch.DOMAIN: { 'platform': 'flux', 'name': 'flux', 'lights': [dev1.entity_id], 'start_colortemp': '1000', 'stop_colortemp': '6000' } }) turn_on_calls = mock_service( self.hass, light.DOMAIN, SERVICE_TURN_ON) switch.turn_on(self.hass, 'switch.flux') self.hass.pool.block_till_done() fire_time_changed(self.hass, test_time) self.hass.pool.block_till_done() call = turn_on_calls[-1] self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 167) self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.461, 0.389])
def test_flux_with_kelvin(self): """Test the flux switch´s mode kelvin.""" platform = loader.get_component('light.test') platform.init() self.assertTrue( light.setup(self.hass, {light.DOMAIN: { CONF_PLATFORM: 'test' }})) dev1 = platform.DEVICES[0] # Verify initial state of light state = self.hass.states.get(dev1.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('color_temp')) test_time = dt_util.now().replace(hour=8, minute=30, second=0) sunset_time = test_time.replace(hour=17, minute=0, second=0) sunrise_time = test_time.replace(hour=5, minute=0, second=0) + timedelta(days=1) with patch('homeassistant.util.dt.now', return_value=test_time): with patch('homeassistant.components.sun.next_rising', return_value=sunrise_time): with patch('homeassistant.components.sun.next_setting', return_value=sunset_time): assert setup_component( self.hass, switch.DOMAIN, { switch.DOMAIN: { 'platform': 'flux', 'name': 'flux', 'lights': [dev1.entity_id], 'mode': 'kelvin' } }) turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON) switch.turn_on(self.hass, 'switch.flux') self.hass.pool.block_till_done() fire_time_changed(self.hass, test_time) self.hass.pool.block_till_done() call = turn_on_calls[-1] self.assertEqual(call.data[light.ATTR_COLOR_TEMP], 3708)
def test_flux_with_kelvin(self): """Test the flux switch´s mode kelvin.""" platform = loader.get_component('light.test') platform.init() self.assertTrue( light.setup(self.hass, {light.DOMAIN: {CONF_PLATFORM: 'test'}})) dev1 = platform.DEVICES[0] # Verify initial state of light state = self.hass.states.get(dev1.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('color_temp')) test_time = dt_util.now().replace(hour=8, minute=30, second=0) sunset_time = test_time.replace(hour=17, minute=0, second=0) sunrise_time = test_time.replace(hour=5, minute=0, second=0) + timedelta(days=1) with patch('homeassistant.util.dt.now', return_value=test_time): with patch('homeassistant.components.sun.next_rising', return_value=sunrise_time): with patch('homeassistant.components.sun.next_setting', return_value=sunset_time): assert setup_component(self.hass, switch.DOMAIN, { switch.DOMAIN: { 'platform': 'flux', 'name': 'flux', 'lights': [dev1.entity_id], 'mode': 'kelvin' } }) turn_on_calls = mock_service( self.hass, light.DOMAIN, SERVICE_TURN_ON) switch.turn_on(self.hass, 'switch.flux') self.hass.pool.block_till_done() fire_time_changed(self.hass, test_time) self.hass.pool.block_till_done() call = turn_on_calls[-1] self.assertEqual(call.data[light.ATTR_COLOR_TEMP], 3708)
def test_show_brightness_if_only_command_topic(self): """Test the brightness if only a command topic is present.""" self.assertTrue(light.setup(self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'brightness_command_topic': 'test_light_rgb/brightness/set', 'command_topic': 'test_light_rgb/set', 'state_topic': 'test_light_rgb/status', } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) self.assertIsNone(state.attributes.get('brightness')) fire_mqtt_message(self.hass, 'test_light_rgb/status', 'ON') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) self.assertEqual(255, state.attributes.get('brightness'))
def test_no_color_or_brightness_if_no_topics(self): self.assertTrue(light.setup(self.hass, { 'light': { 'platform': 'mqtt', 'name': 'test', 'state_topic': 'test_light_rgb/status', 'command_topic': 'test_light_rgb/set', } })) state = self.hass.states.get('light.test') self.assertEqual(STATE_OFF, state.state) self.assertIsNone(state.attributes.get('rgb_color')) self.assertIsNone(state.attributes.get('brightness')) fire_mqtt_message(self.hass, 'test_light_rgb/status', 'ON') self.hass.pool.block_till_done() state = self.hass.states.get('light.test') self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('rgb_color')) self.assertIsNone(state.attributes.get('brightness'))
def test_flux_when_switch_is_off(self): """Test the flux switch when it is off.""" platform = loader.get_component('light.test') platform.init() self.assertTrue( light.setup(self.hass, {light.DOMAIN: { CONF_PLATFORM: 'test' }})) dev1 = platform.DEVICES[0] # Verify initial state of light state = self.hass.states.get(dev1.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('xy_color')) self.assertIsNone(state.attributes.get('brightness')) test_time = dt_util.now().replace(hour=10, minute=30, second=0) sunset_time = test_time.replace(hour=17, minute=0, second=0) sunrise_time = test_time.replace(hour=5, minute=0, second=0) + timedelta(days=1) with patch('homeassistant.util.dt.now', return_value=test_time): with patch('homeassistant.components.sun.next_rising', return_value=sunrise_time): with patch('homeassistant.components.sun.next_setting', return_value=sunset_time): assert setup_component( self.hass, switch.DOMAIN, { switch.DOMAIN: { 'platform': 'flux', 'name': 'flux', 'lights': [dev1.entity_id] } }) turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON) fire_time_changed(self.hass, test_time) self.hass.pool.block_till_done() self.assertEqual(0, len(turn_on_calls))
def setUp(self): # pylint: disable=invalid-name """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() event_decorators.HASS = self.hass self.scanner = loader.get_component( 'device_tracker.test').get_scanner(None, None) self.scanner.reset() self.scanner.come_home('DEV1') loader.get_component('light.test').init() self.assertTrue(device_tracker.setup(self.hass, { device_tracker.DOMAIN: {CONF_PLATFORM: 'test'} })) self.assertTrue(light.setup(self.hass, { light.DOMAIN: {CONF_PLATFORM: 'test'} })) self.assertTrue(sun.setup( self.hass, {sun.DOMAIN: {sun.CONF_ELEVATION: 0}}))
def test_services(self): """ Test the provided services. """ platform = loader.get_component('light.test') platform.init() self.assertTrue( light.setup(self.hass, {light.DOMAIN: { CONF_PLATFORM: 'test' }})) dev1, dev2, dev3 = platform.DEVICES # Test init self.assertTrue(light.is_on(self.hass, dev1.entity_id)) self.assertFalse(light.is_on(self.hass, dev2.entity_id)) self.assertFalse(light.is_on(self.hass, dev3.entity_id)) # Test basic turn_on, turn_off services light.turn_off(self.hass, entity_id=dev1.entity_id) light.turn_on(self.hass, entity_id=dev2.entity_id) self.hass.pool.block_till_done() self.assertFalse(light.is_on(self.hass, dev1.entity_id)) self.assertTrue(light.is_on(self.hass, dev2.entity_id)) # turn on all lights light.turn_on(self.hass) self.hass.pool.block_till_done() self.assertTrue(light.is_on(self.hass, dev1.entity_id)) self.assertTrue(light.is_on(self.hass, dev2.entity_id)) self.assertTrue(light.is_on(self.hass, dev3.entity_id)) # turn off all lights light.turn_off(self.hass) self.hass.pool.block_till_done() self.assertFalse(light.is_on(self.hass, dev1.entity_id)) self.assertFalse(light.is_on(self.hass, dev2.entity_id)) self.assertFalse(light.is_on(self.hass, dev3.entity_id)) # Ensure all attributes process correctly light.turn_on(self.hass, dev1.entity_id, transition=10, brightness=20) light.turn_on(self.hass, dev2.entity_id, rgb_color=[255, 255, 255]) light.turn_on(self.hass, dev3.entity_id, xy_color=[.4, .6]) self.hass.pool.block_till_done() method, data = dev1.last_call('turn_on') self.assertEqual({ light.ATTR_TRANSITION: 10, light.ATTR_BRIGHTNESS: 20 }, data) method, data = dev2.last_call('turn_on') self.assertEqual( {light.ATTR_XY_COLOR: color_util.color_RGB_to_xy(255, 255, 255)}, data) method, data = dev3.last_call('turn_on') self.assertEqual({light.ATTR_XY_COLOR: [.4, .6]}, data) # One of the light profiles prof_name, prof_x, prof_y, prof_bri = 'relax', 0.5119, 0.4147, 144 # Test light profiles light.turn_on(self.hass, dev1.entity_id, profile=prof_name) # Specify a profile and attributes to overwrite it light.turn_on(self.hass, dev2.entity_id, profile=prof_name, brightness=100, xy_color=[.4, .6]) self.hass.pool.block_till_done() method, data = dev1.last_call('turn_on') self.assertEqual( { light.ATTR_BRIGHTNESS: prof_bri, light.ATTR_XY_COLOR: [prof_x, prof_y] }, data) method, data = dev2.last_call('turn_on') self.assertEqual( { light.ATTR_BRIGHTNESS: 100, light.ATTR_XY_COLOR: [.4, .6] }, data) # Test shitty data light.turn_on(self.hass, dev1.entity_id, profile="nonexisting") light.turn_on(self.hass, dev2.entity_id, xy_color=["bla-di-bla", 5]) light.turn_on(self.hass, dev3.entity_id, rgb_color=[255, None, 2]) self.hass.pool.block_till_done() method, data = dev1.last_call('turn_on') self.assertEqual({}, data) method, data = dev2.last_call('turn_on') self.assertEqual({}, data) method, data = dev3.last_call('turn_on') self.assertEqual({}, data) # faulty attributes should not overwrite profile data light.turn_on(self.hass, dev1.entity_id, profile=prof_name, brightness='bright', rgb_color='yellowish') self.hass.pool.block_till_done() method, data = dev1.last_call('turn_on') self.assertEqual( { light.ATTR_BRIGHTNESS: prof_bri, light.ATTR_XY_COLOR: [prof_x, prof_y] }, data)
def test_services(self): """Test the provided services.""" platform = loader.get_component("light.test") platform.init() self.assertTrue(light.setup(self.hass, {light.DOMAIN: {CONF_PLATFORM: "test"}})) dev1, dev2, dev3 = platform.DEVICES # Test init self.assertTrue(light.is_on(self.hass, dev1.entity_id)) self.assertFalse(light.is_on(self.hass, dev2.entity_id)) self.assertFalse(light.is_on(self.hass, dev3.entity_id)) # Test basic turn_on, turn_off, toggle services light.turn_off(self.hass, entity_id=dev1.entity_id) light.turn_on(self.hass, entity_id=dev2.entity_id) self.hass.pool.block_till_done() self.assertFalse(light.is_on(self.hass, dev1.entity_id)) self.assertTrue(light.is_on(self.hass, dev2.entity_id)) # turn on all lights light.turn_on(self.hass) self.hass.pool.block_till_done() self.assertTrue(light.is_on(self.hass, dev1.entity_id)) self.assertTrue(light.is_on(self.hass, dev2.entity_id)) self.assertTrue(light.is_on(self.hass, dev3.entity_id)) # turn off all lights light.turn_off(self.hass) self.hass.pool.block_till_done() self.assertFalse(light.is_on(self.hass, dev1.entity_id)) self.assertFalse(light.is_on(self.hass, dev2.entity_id)) self.assertFalse(light.is_on(self.hass, dev3.entity_id)) # toggle all lights light.toggle(self.hass) self.hass.pool.block_till_done() self.assertTrue(light.is_on(self.hass, dev1.entity_id)) self.assertTrue(light.is_on(self.hass, dev2.entity_id)) self.assertTrue(light.is_on(self.hass, dev3.entity_id)) # toggle all lights light.toggle(self.hass) self.hass.pool.block_till_done() self.assertFalse(light.is_on(self.hass, dev1.entity_id)) self.assertFalse(light.is_on(self.hass, dev2.entity_id)) self.assertFalse(light.is_on(self.hass, dev3.entity_id)) # Ensure all attributes process correctly light.turn_on(self.hass, dev1.entity_id, transition=10, brightness=20) light.turn_on(self.hass, dev2.entity_id, rgb_color=(255, 255, 255)) light.turn_on(self.hass, dev3.entity_id, xy_color=(0.4, 0.6)) self.hass.pool.block_till_done() method, data = dev1.last_call("turn_on") self.assertEqual({light.ATTR_TRANSITION: 10, light.ATTR_BRIGHTNESS: 20}, data) method, data = dev2.last_call("turn_on") self.assertEquals(data[light.ATTR_RGB_COLOR], (255, 255, 255)) method, data = dev3.last_call("turn_on") self.assertEqual({light.ATTR_XY_COLOR: (0.4, 0.6)}, data) # One of the light profiles prof_name, prof_x, prof_y, prof_bri = "relax", 0.5119, 0.4147, 144 # Test light profiles light.turn_on(self.hass, dev1.entity_id, profile=prof_name) # Specify a profile and attributes to overwrite it light.turn_on(self.hass, dev2.entity_id, profile=prof_name, brightness=100, xy_color=(0.4, 0.6)) self.hass.pool.block_till_done() method, data = dev1.last_call("turn_on") self.assertEqual({light.ATTR_BRIGHTNESS: prof_bri, light.ATTR_XY_COLOR: (prof_x, prof_y)}, data) method, data = dev2.last_call("turn_on") self.assertEqual({light.ATTR_BRIGHTNESS: 100, light.ATTR_XY_COLOR: (0.4, 0.6)}, data) # Test shitty data light.turn_on(self.hass) light.turn_on(self.hass, dev1.entity_id, profile="nonexisting") light.turn_on(self.hass, dev2.entity_id, xy_color=["bla-di-bla", 5]) light.turn_on(self.hass, dev3.entity_id, rgb_color=[255, None, 2]) self.hass.pool.block_till_done() method, data = dev1.last_call("turn_on") self.assertEqual({}, data) method, data = dev2.last_call("turn_on") self.assertEqual({}, data) method, data = dev3.last_call("turn_on") self.assertEqual({}, data) # faulty attributes will not trigger a service call light.turn_on(self.hass, dev1.entity_id, profile=prof_name, brightness="bright", rgb_color="yellowish") self.hass.pool.block_till_done() method, data = dev1.last_call("turn_on") self.assertEqual({}, data)
def test_services(self): """ Test the provided services. """ platform = loader.get_component('light.test') platform.init() self.assertTrue( light.setup(self.hass, {light.DOMAIN: {CONF_PLATFORM: 'test'}})) dev1, dev2, dev3 = platform.DEVICES # Test init self.assertTrue(light.is_on(self.hass, dev1.entity_id)) self.assertFalse(light.is_on(self.hass, dev2.entity_id)) self.assertFalse(light.is_on(self.hass, dev3.entity_id)) # Test basic turn_on, turn_off services light.turn_off(self.hass, entity_id=dev1.entity_id) light.turn_on(self.hass, entity_id=dev2.entity_id) self.hass.pool.block_till_done() self.assertFalse(light.is_on(self.hass, dev1.entity_id)) self.assertTrue(light.is_on(self.hass, dev2.entity_id)) # turn on all lights light.turn_on(self.hass) self.hass.pool.block_till_done() self.assertTrue(light.is_on(self.hass, dev1.entity_id)) self.assertTrue(light.is_on(self.hass, dev2.entity_id)) self.assertTrue(light.is_on(self.hass, dev3.entity_id)) # turn off all lights light.turn_off(self.hass) self.hass.pool.block_till_done() self.assertFalse(light.is_on(self.hass, dev1.entity_id)) self.assertFalse(light.is_on(self.hass, dev2.entity_id)) self.assertFalse(light.is_on(self.hass, dev3.entity_id)) # Ensure all attributes process correctly light.turn_on(self.hass, dev1.entity_id, transition=10, brightness=20) light.turn_on( self.hass, dev2.entity_id, rgb_color=[255, 255, 255]) light.turn_on(self.hass, dev3.entity_id, xy_color=[.4, .6]) self.hass.pool.block_till_done() method, data = dev1.last_call('turn_on') self.assertEqual( {light.ATTR_TRANSITION: 10, light.ATTR_BRIGHTNESS: 20}, data) method, data = dev2.last_call('turn_on') self.assertEqual( {light.ATTR_XY_COLOR: util.color_RGB_to_xy(255, 255, 255)}, data) method, data = dev3.last_call('turn_on') self.assertEqual({light.ATTR_XY_COLOR: [.4, .6]}, data) # One of the light profiles prof_name, prof_x, prof_y, prof_bri = 'relax', 0.5119, 0.4147, 144 # Test light profiles light.turn_on(self.hass, dev1.entity_id, profile=prof_name) # Specify a profile and attributes to overwrite it light.turn_on( self.hass, dev2.entity_id, profile=prof_name, brightness=100, xy_color=[.4, .6]) self.hass.pool.block_till_done() method, data = dev1.last_call('turn_on') self.assertEqual( {light.ATTR_BRIGHTNESS: prof_bri, light.ATTR_XY_COLOR: [prof_x, prof_y]}, data) method, data = dev2.last_call('turn_on') self.assertEqual( {light.ATTR_BRIGHTNESS: 100, light.ATTR_XY_COLOR: [.4, .6]}, data) # Test shitty data light.turn_on(self.hass, dev1.entity_id, profile="nonexisting") light.turn_on(self.hass, dev2.entity_id, xy_color=["bla-di-bla", 5]) light.turn_on(self.hass, dev3.entity_id, rgb_color=[255, None, 2]) self.hass.pool.block_till_done() method, data = dev1.last_call('turn_on') self.assertEqual({}, data) method, data = dev2.last_call('turn_on') self.assertEqual({}, data) method, data = dev3.last_call('turn_on') self.assertEqual({}, data) # faulty attributes should not overwrite profile data light.turn_on( self.hass, dev1.entity_id, profile=prof_name, brightness='bright', rgb_color='yellowish') self.hass.pool.block_till_done() method, data = dev1.last_call('turn_on') self.assertEqual( {light.ATTR_BRIGHTNESS: prof_bri, light.ATTR_XY_COLOR: [prof_x, prof_y]}, data)
def from_config_file(config_path): """ Starts home assistant with all possible functionality based on a config file. """ statusses = [] # Read config config = ConfigParser.SafeConfigParser() config.read(config_path) # Init core bus = ha.Bus() statemachine = ha.StateMachine(bus) # Device scanner if config.has_option('tomato', 'host') and \ config.has_option('tomato', 'username') and \ config.has_option('tomato', 'password') and \ config.has_option('tomato', 'http_id'): device_scanner = device.TomatoDeviceScanner( config.get('tomato', 'host'), config.get('tomato', 'username'), config.get('tomato', 'password'), config.get('tomato', 'http_id')) statusses.append(("Device Scanner - Tomato", device_scanner.success_init)) elif config.has_option('netgear', 'host') and \ config.has_option('netgear', 'username') and \ config.has_option('netgear', 'password'): device_scanner = device.NetgearDeviceScanner( config.get('netgear', 'host'), config.get('netgear', 'username'), config.get('netgear', 'password')) statusses.append(("Device Scanner - Netgear", device_scanner.success_init)) else: device_scanner = None if device_scanner and not device_scanner.success_init: device_scanner = None # Device Tracker if device_scanner: device.DeviceTracker(bus, statemachine, device_scanner) statusses.append(("Device Tracker", True)) # Sun tracker if config.has_option("common", "latitude") and \ config.has_option("common", "longitude"): statusses.append(("Weather - Ephem", sun.setup( bus, statemachine, config.get("common", "latitude"), config.get("common", "longitude")))) # Chromecast if config.has_option("chromecast", "host"): chromecast_started = chromecast.setup(bus, statemachine, config.get("chromecast", "host")) statusses.append(("Chromecast", chromecast_started)) else: chromecast_started = False # Light control if config.has_section("hue"): if config.has_option("hue", "host"): light_control = light.HueLightControl(config.get("hue", "host")) else: light_control = light.HueLightControl() statusses.append(("Light Control - Hue", light_control.success_init)) else: light_control = None # Light trigger if light_control: light.setup(bus, statemachine, light_control) statusses.append(("Light Trigger", device_sun_light_trigger.setup( bus, statemachine))) if config.has_option("downloader", "download_dir"): statusses.append(("Downloader", downloader.setup( bus, config.get("downloader", "download_dir")))) # Currently only works with Chromecast or Light_Control if chromecast_started or light_control: statusses.append(("General", general.setup(bus, statemachine))) statusses.append(("Browser", browser.setup(bus))) statusses.append(("Media Buttons", keyboard.setup(bus))) # Init HTTP interface if config.has_option("httpinterface", "api_password"): httpinterface.HTTPInterface( bus, statemachine, config.get("httpinterface", "api_password")) statusses.append(("HTTPInterface", True)) logger = logging.getLogger(__name__) for component, success_init in statusses: status = "initialized" if success_init else "Failed to initialize" logger.info("{}: {}".format(component, status)) ha.start_home_assistant(bus)
def test_flux_with_multiple_lights(self): """Test the flux switch with multiple light entities.""" platform = loader.get_component('light.test') platform.init() self.assertTrue( light.setup(self.hass, {light.DOMAIN: { CONF_PLATFORM: 'test' }})) dev1, dev2, dev3 = platform.DEVICES light.turn_on(self.hass, entity_id=dev2.entity_id) self.hass.pool.block_till_done() light.turn_on(self.hass, entity_id=dev3.entity_id) self.hass.pool.block_till_done() state = self.hass.states.get(dev1.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('xy_color')) self.assertIsNone(state.attributes.get('brightness')) state = self.hass.states.get(dev2.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('xy_color')) self.assertIsNone(state.attributes.get('brightness')) state = self.hass.states.get(dev3.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('xy_color')) self.assertIsNone(state.attributes.get('brightness')) test_time = dt_util.now().replace(hour=12, minute=0, second=0) sunset_time = test_time.replace(hour=17, minute=0, second=0) sunrise_time = test_time.replace(hour=5, minute=0, second=0) + timedelta(days=1) with patch('homeassistant.util.dt.now', return_value=test_time): with patch('homeassistant.components.sun.next_rising', return_value=sunrise_time): with patch('homeassistant.components.sun.next_setting', return_value=sunset_time): assert setup_component( self.hass, switch.DOMAIN, { switch.DOMAIN: { 'platform': 'flux', 'name': 'flux', 'lights': [ dev1.entity_id, dev2.entity_id, dev3.entity_id ] } }) turn_on_calls = mock_service(self.hass, light.DOMAIN, SERVICE_TURN_ON) switch.turn_on(self.hass, 'switch.flux') self.hass.pool.block_till_done() fire_time_changed(self.hass, test_time) self.hass.pool.block_till_done() call = turn_on_calls[-1] self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 171) self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.452, 0.386]) call = turn_on_calls[-2] self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 171) self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.452, 0.386]) call = turn_on_calls[-3] self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 171) self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.452, 0.386])
def test_flux_with_multiple_lights(self): """Test the flux switch with multiple light entities.""" platform = loader.get_component('light.test') platform.init() self.assertTrue( light.setup(self.hass, {light.DOMAIN: {CONF_PLATFORM: 'test'}})) dev1, dev2, dev3 = platform.DEVICES light.turn_on(self.hass, entity_id=dev2.entity_id) self.hass.pool.block_till_done() light.turn_on(self.hass, entity_id=dev3.entity_id) self.hass.pool.block_till_done() state = self.hass.states.get(dev1.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('xy_color')) self.assertIsNone(state.attributes.get('brightness')) state = self.hass.states.get(dev2.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('xy_color')) self.assertIsNone(state.attributes.get('brightness')) state = self.hass.states.get(dev3.entity_id) self.assertEqual(STATE_ON, state.state) self.assertIsNone(state.attributes.get('xy_color')) self.assertIsNone(state.attributes.get('brightness')) test_time = dt_util.now().replace(hour=12, minute=0, second=0) sunset_time = test_time.replace(hour=17, minute=0, second=0) sunrise_time = test_time.replace(hour=5, minute=0, second=0) + timedelta(days=1) with patch('homeassistant.util.dt.now', return_value=test_time): with patch('homeassistant.components.sun.next_rising', return_value=sunrise_time): with patch('homeassistant.components.sun.next_setting', return_value=sunset_time): assert setup_component(self.hass, switch.DOMAIN, { switch.DOMAIN: { 'platform': 'flux', 'name': 'flux', 'lights': [dev1.entity_id, dev2.entity_id, dev3.entity_id] } }) turn_on_calls = mock_service( self.hass, light.DOMAIN, SERVICE_TURN_ON) switch.turn_on(self.hass, 'switch.flux') self.hass.pool.block_till_done() fire_time_changed(self.hass, test_time) self.hass.pool.block_till_done() call = turn_on_calls[-1] self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 171) self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.452, 0.386]) call = turn_on_calls[-2] self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 171) self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.452, 0.386]) call = turn_on_calls[-3] self.assertEqual(call.data[light.ATTR_BRIGHTNESS], 171) self.assertEqual(call.data[light.ATTR_XY_COLOR], [0.452, 0.386])