def test_platform_validator():
    """Test platform validation."""
    # Prepares loading
    get_test_home_assistant()

    schema = vol.Schema(cv.platform_validator('light'))

    with pytest.raises(vol.MultipleInvalid):
        schema('platform_that_does_not_exist')

    schema('hue')
Esempio n. 2
0
    def setup_method(self):
        """Setup things to be run when tests are started."""
        self.hass = get_test_home_assistant()

        setup_component(
            self.hass, http.DOMAIN,
            {http.DOMAIN: {http.CONF_SERVER_PORT: get_test_instance_port()}})

        config = {
            ip.DOMAIN: {
                'platform': 'demo'
            },
            'camera': {
                'platform': 'demo'
            },
        }

        with patch('homeassistant.components.image_processing.demo.'
                   'DemoImageProcessing.should_poll',
                   new_callable=PropertyMock(return_value=False)):
            setup_component(self.hass, ip.DOMAIN, config)

        state = self.hass.states.get('camera.demo_camera')
        self.url = "{0}{1}".format(
            self.hass.config.api.base_url,
            state.attributes.get(ATTR_ENTITY_PICTURE))
    def setup_method(self):
        """Setup things to be run when tests are started."""
        self.url = "https://example.com/"
        self.config = {
            rc.DOMAIN: {
                'get_test': {
                    'url': self.url,
                    'method': 'get',
                },
                'post_test': {
                    'url': self.url,
                    'method': 'post',
                },
                'put_test': {
                    'url': self.url,
                    'method': 'put',
                },
                'delete_test': {
                    'url': self.url,
                    'method': 'delete',
                },
            }
        }

        self.hass = get_test_home_assistant()
 def setUp(self):  # pylint: disable=invalid-name
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     with patch('homeassistant.core.Config.path', return_value=':memory:'):
         recorder.setup(self.hass, {})
     self.hass.start()
     recorder._INSTANCE.block_till_done()
Esempio n. 5
0
    def setUp(self):  # pylint: disable=invalid-name
        """Setup things to be run when tests are started."""
        self.hass = get_test_home_assistant()
        self.events = []
        self.service1 = MagicMock()
        self.service2 = MagicMock()

        def mock_get_service(hass, config):
            if config['name'] == 'demo1':
                return self.service1
            else:
                return self.service2

        with assert_setup_component(2), \
                patch.object(demo, 'get_service', mock_get_service):
            setup_component(self.hass, notify.DOMAIN, {
                'notify': [{
                    'name': 'demo1',
                    'platform': 'demo'
                }, {
                    'name': 'demo2',
                    'platform': 'demo'
                }]
            })

        self.service = group.get_service(self.hass, {'services': [
            {'service': 'demo1'},
            {'service': 'demo2',
             'data': {'target': 'unnamed device',
                      'data': {'test': 'message'}}}]})

        assert self.service is not None
Esempio n. 6
0
    def setup_method(self):
        """Set up things to be run when tests are started."""
        self.hass = get_test_home_assistant()

        config = {
            ip.DOMAIN: {
                'platform': 'demo'
            },
            'camera': {
                'platform': 'demo'
            },
        }

        with patch('homeassistant.components.image_processing.demo.'
                   'DemoImageProcessingFace.should_poll',
                   new_callable=PropertyMock(return_value=False)):
            setup_component(self.hass, ip.DOMAIN, config)

        state = self.hass.states.get('camera.demo_camera')
        self.url = "{0}{1}".format(
            self.hass.config.api.base_url,
            state.attributes.get(ATTR_ENTITY_PICTURE))

        self.face_events = []

        @callback
        def mock_face_event(event):
            """Mock event."""
            self.face_events.append(event)

        self.hass.bus.listen('image_processing.detect_face', mock_face_event)
    def setUp(self):  # pylint: disable=invalid-name
        self.hass = get_test_home_assistant()

        self.mock_mp_1 = MockMediaPlayer(self.hass, 'mock1')
        self.mock_mp_1.update_ha_state()

        self.mock_mp_2 = MockMediaPlayer(self.hass, 'mock2')
        self.mock_mp_2.update_ha_state()

        self.mock_mute_switch_id = switch.ENTITY_ID_FORMAT.format('mute')
        self.hass.states.set(self.mock_mute_switch_id, STATE_OFF)

        self.mock_state_switch_id = switch.ENTITY_ID_FORMAT.format('state')
        self.hass.states.set(self.mock_state_switch_id, STATE_OFF)

        self.config_children_only = \
            {'name': 'test', 'platform': 'universal',
             'children': [media_player.ENTITY_ID_FORMAT.format('mock1'),
                          media_player.ENTITY_ID_FORMAT.format('mock2')]}
        self.config_children_and_attr = \
            {'name': 'test', 'platform': 'universal',
             'children': [media_player.ENTITY_ID_FORMAT.format('mock1'),
                          media_player.ENTITY_ID_FORMAT.format('mock2')],
             'attributes': {
                 'is_volume_muted': self.mock_mute_switch_id,
                 'state': self.mock_state_switch_id}}
Esempio n. 8
0
    def setUp(self):  # pylint: disable=invalid-name
        """Setup things to be run when tests are started."""
        self.hass = get_test_home_assistant()
        self.events = []
        self.assertTrue(setup_component(self.hass, notify.DOMAIN, {
            'notify': [{
                'name': 'demo1',
                'platform': 'demo'
            }, {
                'name': 'demo2',
                'platform': 'demo'
            }]
        }))

        self.service = group.get_service(self.hass, {'services': [
            {'service': 'demo1'},
            {'service': 'demo2',
             'data': {'target': 'unnamed device',
                      'data': {'test': 'message'}}}]})

        assert self.service is not None

        def record_event(event):
            """Record event to send notification."""
            self.events.append(event)

        self.hass.bus.listen("notify", record_event)
 def setUp(self):  # pylint: disable=invalid-name
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     self.hass.config.units = METRIC_SYSTEM
     self.assertTrue(run_coroutine_threadsafe(
         comps.async_setup(self.hass, {}), self.hass.loop
     ).result())
Esempio n. 10
0
 def setUp(self):  # pylint: disable=invalid-name
     """Set up things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     self.mailer = MockSMTP('localhost', 25, 5, '*****@*****.**', 1,
                            'testuser', 'testpass',
                            ['*****@*****.**', '*****@*****.**'],
                            'HomeAssistant', 0)
Esempio n. 11
0
    def setup_method(self, method):
        """Setup the test."""
        if method == self.test_from_config_file:
            return

        self.hass = get_test_home_assistant()
        self.backup_cache = loader._COMPONENT_CACHE
Esempio n. 12
0
 def setup_method(self, method):
     """Setup things to be run when tests are started."""
     self.entity = entity.Entity()
     self.entity.entity_id = 'test.overwrite_hidden_true'
     self.hass = self.entity.hass = get_test_home_assistant()
     self.entity.schedule_update_ha_state()
     self.hass.block_till_done()
Esempio n. 13
0
    def setUp(self):
        """Setup things to be run when tests are started."""
        self.hass = get_test_home_assistant()

        # Set our timezone to CST/Regina so we can check calculations
        # This keeps UTC-6 all year round
        dt_util.set_default_time_zone(dt_util.get_time_zone('America/Regina'))
 def setup_method(self, method):
     """Set up things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     self.rs = cmd_rs.CommandCover(self.hass, 'foo',
                                   'command_open', 'command_close',
                                   'command_stop', 'command_state',
                                   None)
def test_filling_the_cache():
    """Test filling the cache from the DB."""
    test_entity_id1 = 'input_boolean.b1'
    test_entity_id2 = 'input_boolean.b2'

    hass = get_test_home_assistant()
    hass.state = CoreState.starting

    init_recorder_component(hass)

    _add_data_in_last_run(hass, {
        test_entity_id1: 'on',
        test_entity_id2: 'off',
    })

    hass.block_till_done()
    setup_component(hass, input_boolean.DOMAIN, {
        input_boolean.DOMAIN: {
            'b1': None,
            'b2': None,
        }})

    hass.start()

    state = hass.states.get('input_boolean.b1')
    assert state
    assert state.state == 'on'

    state = hass.states.get('input_boolean.b2')
    assert state
    assert state.state == 'off'

    hass.stop()
Esempio n. 16
0
    def test_remove_lib_on_upgrade(self, mock_os, mock_shutil):
        """Test removal of library on upgrade."""
        ha_version = '0.7.0'

        mock_os.path.isdir = mock.Mock(return_value=True)

        mock_open = mock.mock_open()
        with mock.patch('homeassistant.config.open', mock_open, create=True):
            opened_file = mock_open.return_value
            opened_file.readline.return_value = ha_version

            self.hass = get_test_home_assistant()
            self.hass.config.path = mock.Mock()

            config_util.process_ha_config_upgrade(self.hass)

            hass_path = self.hass.config.path.return_value

            self.assertEqual(mock_os.path.isdir.call_count, 1)
            self.assertEqual(
                mock_os.path.isdir.call_args, mock.call(hass_path)
            )

            self.assertEqual(mock_shutil.rmtree.call_count, 1)
            self.assertEqual(
                mock_shutil.rmtree.call_args, mock.call(hass_path)
            )
Esempio n. 17
0
def setUpModule():   # pylint: disable=invalid-name
    """Initialize a Home Assistant server for testing this module."""
    global hass

    hass = get_test_home_assistant()

    bootstrap.setup_component(
        hass, http.DOMAIN,
        {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD,
         http.CONF_SERVER_PORT: SERVER_PORT}})

    hass.services.register('test', 'alexa', lambda call: calls.append(call))

    bootstrap.setup_component(hass, alexa.DOMAIN, {
        'alexa': {
            'intents': {
                'WhereAreWeIntent': {
                    'speech': {
                        'type': 'plaintext',
                        'text':
                        """
                            {%- if is_state('device_tracker.paulus', 'home')
                                   and is_state('device_tracker.anne_therese',
                                                'home') -%}
                                You are both home, you silly
                            {%- else -%}
                                Anne Therese is at {{
                                    states("device_tracker.anne_therese")
                                }} and Paulus is at {{
                                    states("device_tracker.paulus")
                                }}
                            {% endif %}
                        """,
                    }
                },
                'GetZodiacHoroscopeIntent': {
                    'speech': {
                        'type': 'plaintext',
                        'text': 'You told us your sign is {{ ZodiacSign }}.',
                    }
                },
                'CallServiceIntent': {
                    'speech': {
                        'type': 'plaintext',
                        'text': 'Service called',
                    },
                    'action': {
                        'service': 'test.alexa',
                        'data_template': {
                            'hello': '{{ ZodiacSign }}'
                        },
                        'entity_id': 'switch.test',
                    }
                }
            }
        }
    })

    hass.start()
    time.sleep(0.05)
Esempio n. 18
0
 def setUp(self):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     controller_mock = mock.MagicMock()
     dev_dict = {'address': 'a1', 'name': 'fake_switch'}
     self.switch = mochad.MochadSwitch(self.hass, controller_mock,
                                       dev_dict)
Esempio n. 19
0
    def test_debounce(self):
        """Test add_timeout decorator function."""
        def demo_func(*args):
            nonlocal arguments, counter
            counter += 1
            arguments = args

        arguments = None
        counter = 0
        hass = get_test_home_assistant()
        mock = Mock(hass=hass)

        debounce_demo = debounce(demo_func)
        self.assertEqual(debounce_demo.__name__, 'demo_func')
        now = datetime(2018, 1, 1, 20, 0, 0, tzinfo=dt_util.UTC)

        with patch('homeassistant.util.dt.utcnow', return_value=now):
            debounce_demo(mock, 'value')
        hass.bus.fire(
            EVENT_TIME_CHANGED, {ATTR_NOW: now + timedelta(seconds=3)})
        hass.block_till_done()
        assert counter == 1
        assert len(arguments) == 2

        with patch('homeassistant.util.dt.utcnow', return_value=now):
            debounce_demo(mock, 'value')
            debounce_demo(mock, 'value')

        hass.bus.fire(
            EVENT_TIME_CHANGED, {ATTR_NOW: now + timedelta(seconds=3)})
        hass.block_till_done()
        assert counter == 2

        hass.stop()
Esempio n. 20
0
 def setUp(self):
     """Initialize unit test data."""
     self.hass = get_test_home_assistant()
     self.assertTrue(fan.setup(self.hass, {'fan': {
         'platform': 'demo',
     }}))
     self.hass.pool.block_till_done()
Esempio n. 21
0
def setUpModule():   # pylint: disable=invalid-name
    """Initalization of a Home Assistant server and Slave instance."""
    global hass, slave, master_api

    hass = get_test_home_assistant()

    hass.bus.listen('test_event', lambda _: _)
    hass.states.set('test.test', 'a_state')

    bootstrap.setup_component(
        hass, http.DOMAIN,
        {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD,
         http.CONF_SERVER_PORT: MASTER_PORT}})

    bootstrap.setup_component(hass, 'api')

    hass.start()

    master_api = remote.API("127.0.0.1", API_PASSWORD, MASTER_PORT)

    # Start slave
    slave = remote.HomeAssistant(master_api)
    bootstrap.setup_component(
        slave, http.DOMAIN,
        {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD,
         http.CONF_SERVER_PORT: SLAVE_PORT}})

    slave.start()
Esempio n. 22
0
    def test_home_accessory(self):
        """Test HomeAccessory class."""
        hass = get_test_home_assistant()

        acc = HomeAccessory(hass, 'Home Accessory', 'homekit.accessory', 2, '')
        self.assertEqual(acc.hass, hass)
        self.assertEqual(acc.display_name, 'Home Accessory')
        self.assertEqual(acc.category, 1)  # Category.OTHER
        self.assertEqual(len(acc.services), 1)
        serv = acc.services[0]  # SERV_ACCESSORY_INFO
        self.assertEqual(
            serv.get_characteristic(CHAR_MODEL).value, 'homekit.accessory')

        hass.states.set('homekit.accessory', 'on')
        hass.block_till_done()
        acc.run()
        hass.states.set('homekit.accessory', 'off')
        hass.block_till_done()

        acc = HomeAccessory('hass', 'test_name', 'test_model', 2, '')
        self.assertEqual(acc.display_name, 'test_name')
        self.assertEqual(acc.aid, 2)
        self.assertEqual(len(acc.services), 1)
        serv = acc.services[0]  # SERV_ACCESSORY_INFO
        self.assertEqual(
            serv.get_characteristic(CHAR_MODEL).value, 'test_model')

        hass.stop()
Esempio n. 23
0
def setUpModule():  # pylint: disable=invalid-name
    """Initalization of a Home Assistant server and Slave instance."""
    global hass, slave, master_api

    hass = get_test_home_assistant()

    hass.bus.listen("test_event", lambda _: _)
    hass.states.set("test.test", "a_state")

    bootstrap.setup_component(
        hass, http.DOMAIN, {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: MASTER_PORT}}
    )

    bootstrap.setup_component(hass, "api")

    hass.start()
    time.sleep(0.05)

    master_api = remote.API("127.0.0.1", API_PASSWORD, MASTER_PORT)

    # Start slave
    loop = asyncio.new_event_loop()

    # FIXME: should not be a daemon
    threading.Thread(name="SlaveThread", daemon=True, target=loop.run_forever).start()

    slave = remote.HomeAssistant(master_api, loop=loop)
    slave.config.config_dir = get_test_config_dir()
    slave.config.skip_pip = True
    bootstrap.setup_component(
        slave, http.DOMAIN, {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: SLAVE_PORT}}
    )

    with patch.object(ha, "_async_create_timer", return_value=None):
        slave.start()
    def setUp(self):  # pylint: disable=invalid-name
        """ Init needed objects. """
        self.hass = get_test_home_assistant()
        loader.prepare(self.hass)

        self.known_dev_path = self.hass.config.path(
            device_tracker.KNOWN_DEVICES_FILE)
Esempio n. 25
0
    def setUp(self):     # pylint: disable=invalid-name
        """Setup things to be run when tests are started."""
        self.hass = get_test_home_assistant()
        self.hass.states.set("light.Bowl", "on")
        self.hass.states.set("switch.AC", "off")

        event_decorators.HASS = self.hass
Esempio n. 26
0
    def setUp(self):  # pylint: disable=invalid-name
        """ Init needed objects. """
        self.hass = get_test_home_assistant()
        self.assertTrue(comps.setup(self.hass, {}))

        self.hass.states.set('light.Bowl', STATE_ON)
        self.hass.states.set('light.Ceiling', STATE_OFF)
Esempio n. 27
0
 def setUp(self):
     """Initialize values for this testcase class."""
     self.hass = get_test_home_assistant()
     self.key = 'foo'
     self.lat = self.hass.config.latitude = 37.8267
     self.lon = self.hass.config.longitude = -122.423
     self.entities = []
Esempio n. 28
0
 def setUp(self):  # pylint: disable=invalid-name
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     self.hass.config.units = METRIC_SYSTEM
     self.assertTrue(hvac.setup(self.hass, {'hvac': {
         'platform': 'demo',
     }}))
Esempio n. 29
0
    def setUp(self):  # pylint: disable=invalid-name
        """Set up test variables."""
        serial_number = "12345"
        temperature_unit = "F"

        thermostat = Mock(
            serial_number=serial_number,
            room="Master bathroom",
            online=True,
            heating=True,
            temperature=2222,
            celsius=22,
            fahrenheit=72,
            max_celsius=69,
            max_fahrenheit=157,
            min_celsius=5,
            min_fahrenheit=41,
            schedule_mode=SCHEDULE_RUN,
            target_celsius=22,
            target_fahrenheit=72)

        thermostat.get_data = Mock()
        thermostat.resume_schedule = Mock()

        self.api = Mock()
        self.api.get_thermostat.return_value = thermostat

        self.hass = get_test_home_assistant()
        self.thermostat = nuheat.NuHeatThermostat(
            self.api, serial_number, temperature_unit)
Esempio n. 30
0
 def setup_method(self, method):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     self.hass.config.latitude = 32.87336
     self.hass.config.longitude = 117.22743
     self.port = mock.MagicMock()
     self.switch = mfi.MfiSwitch(self.port)
Esempio n. 31
0
 def setUp(self):
     """Init needed objects."""
     self.hass = get_test_home_assistant()
Esempio n. 32
0
 def setUp(self):  # pylint: disable=invalid-name
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     self.player = SyncMediaPlayer(self.hass)
Esempio n. 33
0
 def setUp(self):  # pylint: disable=invalid-name
     self.hass = get_test_home_assistant()
Esempio n. 34
0
 def setup_class(cls):
     """Setup things to be run when tests are started."""
     cls.hass = get_test_home_assistant()
Esempio n. 35
0
 def setUp(self):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant(0)
     self.hass.config.components = ['rfxtrx']
Esempio n. 36
0
 def setUp(self):  # pylint: disable=invalid-name
     """Set up things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     self.mock_publish = mock_mqtt_component(self.hass)
Esempio n. 37
0
 def setUp(self):  # pylint: disable=invalid-name
     """Setup things to be run when tests are started."""
     self.entity = entity.Entity()
     self.entity.entity_id = 'test.overwrite_hidden_true'
     self.hass = self.entity.hass = get_test_home_assistant()
     self.entity.update_ha_state()
Esempio n. 38
0
 def setup_method(self, method):
     """Set up things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     self.mock_storage = mock_storage()
     self.mock_storage.__enter__()
Esempio n. 39
0
 def setUp(self):
     """Set up things to run when tests begin."""
     self.hass = get_test_home_assistant()
Esempio n. 40
0
 def setup_method(self, _):
     """Set up things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     mock_component(self.hass, 'zone')
Esempio n. 41
0
 def setUp(self):
     """Setup things to be run when tests are started."""
     super(TestMochadSwitchSetup, self).setUp()
     self.hass = get_test_home_assistant()
Esempio n. 42
0
 def setup_method(self, method):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
Esempio n. 43
0
 def setUp(self):     # pylint: disable=invalid-name
     """Run when tests are started."""
     self.hass = get_test_home_assistant()
     core_components.setup(self.hass, {})
Esempio n. 44
0
 def setUp(self):  # pylint: disable=invalid-name
     """Initialize a test Home Assistant instance."""
     self.hass = get_test_home_assistant()
 def setUp(self):
     """Initialize values for this testcase class."""
     self.hass = get_test_home_assistant()
     self.DEFAULT_TIME_ZONE = dt_util.DEFAULT_TIME_ZONE
Esempio n. 46
0
 def setUp(self):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
 def setup_method(self, method):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass, 'super_secret')
Esempio n. 48
0
 def setup_method(self, method):
     """Set up the test."""
     self.hass = get_test_home_assistant()
    def setUp(self):
        """Set up things to be run when tests are started."""
        self.hass = get_test_home_assistant()

        self.addCleanup(self.tear_down_cleanup)
 def setUp(self):
     """Initialize values for this testcase class."""
     self.hass = get_test_home_assistant()
     self.config = copy.deepcopy(VALID_CONFIG)
Esempio n. 51
0
 def setUp(self):
     """Initialize values for this testcase class."""
     self.DEVICES = []
     self.hass = get_test_home_assistant()
     self.hass.config.time_zone = "America/Los_Angeles"
     self.addCleanup(self.tear_down_cleanup)
Esempio n. 52
0
 def setUp(self):  # pylint: disable=invalid-name
     """Setup the tests."""
     self.hass = get_test_home_assistant()
Esempio n. 53
0
 def setup_method(self, method):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     self.hass.config.latitude = 32.87336
     self.hass.config.longitude = 117.22743
Esempio n. 54
0
 def setUp(self):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     self.yaml_devices = self.hass.config.path(device_tracker.YAML_DEVICES)
Esempio n. 55
0
    def setup_method(self, _):
        """Setup things to be run when tests are started."""
        self.hass = get_test_home_assistant()
        mock_mqtt_component(self.hass)
        mock_component(self.hass, 'group')
        mock_component(self.hass, 'zone')

        patcher = patch('homeassistant.components.device_tracker.'
                        'DeviceTracker.async_update_config')
        patcher.start()
        self.addCleanup(patcher.stop)

        orig_context = owntracks.OwnTracksContext

        def store_context(*args):
            self.context = orig_context(*args)
            return self.context

        with patch('homeassistant.components.device_tracker.async_load_config',
                   return_value=mock_coro([])), \
                patch('homeassistant.components.device_tracker.'
                      'load_yaml_config_file', return_value=mock_coro({})), \
                patch.object(owntracks, 'OwnTracksContext', store_context), \
                assert_setup_component(1, device_tracker.DOMAIN):
            assert setup_component(self.hass, device_tracker.DOMAIN, {
                device_tracker.DOMAIN: {
                    CONF_PLATFORM: 'owntracks',
                    CONF_MAX_GPS_ACCURACY: 200,
                    CONF_WAYPOINT_IMPORT: True,
                    CONF_WAYPOINT_WHITELIST: ['jon', 'greg']
                }})

        self.hass.states.set(
            'zone.inner', 'zoning',
            {
                'name': 'zone',
                'latitude': 2.1,
                'longitude': 1.1,
                'radius': 10
            })

        self.hass.states.set(
            'zone.inner_2', 'zoning',
            {
                'name': 'zone',
                'latitude': 2.1,
                'longitude': 1.1,
                'radius': 10
            })

        self.hass.states.set(
            'zone.outer', 'zoning',
            {
                'name': 'zone',
                'latitude': 2.0,
                'longitude': 1.0,
                'radius': 100000
            })

        # Clear state between teste
        self.hass.states.set(DEVICE_TRACKER_STATE, None)
Esempio n. 56
0
 def setUp(self):
     """Initialize values for this test case class."""
     self.hass = get_test_home_assistant()
Esempio n. 57
0
 def setUp(self):  # pylint: disable=invalid-name
     """Set up things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     self.skip_teardown_stop = False
Esempio n. 58
0
    def setUp(self):  # pylint: disable=invalid-name
        """ Init needed objects. """
        self.hass = get_test_home_assistant()

        self.known_dev_path = self.hass.config.path(
            device_tracker.KNOWN_DEVICES_FILE)
    def setUp(self):  # pylint: disable=invalid-name
        """Set up things to be run when tests are started."""
        self.hass = get_test_home_assistant()

        self.mock_mp_1 = MockMediaPlayer(self.hass, "mock1")
        self.mock_mp_1.schedule_update_ha_state()

        self.mock_mp_2 = MockMediaPlayer(self.hass, "mock2")
        self.mock_mp_2.schedule_update_ha_state()

        self.hass.block_till_done()

        self.mock_mute_switch_id = switch.ENTITY_ID_FORMAT.format("mute")
        self.hass.states.set(self.mock_mute_switch_id, STATE_OFF)

        self.mock_state_switch_id = switch.ENTITY_ID_FORMAT.format("state")
        self.hass.states.set(self.mock_state_switch_id, STATE_OFF)

        self.mock_volume_id = f"{input_number.DOMAIN}.volume_level"
        self.hass.states.set(self.mock_volume_id, 0)

        self.mock_source_list_id = f"{input_select.DOMAIN}.source_list"
        self.hass.states.set(self.mock_source_list_id, ["dvd", "htpc"])

        self.mock_source_id = f"{input_select.DOMAIN}.source"
        self.hass.states.set(self.mock_source_id, "dvd")

        self.mock_sound_mode_list_id = f"{input_select.DOMAIN}.sound_mode_list"
        self.hass.states.set(self.mock_sound_mode_list_id, ["music", "movie"])

        self.mock_sound_mode_id = f"{input_select.DOMAIN}.sound_mode"
        self.hass.states.set(self.mock_sound_mode_id, "music")

        self.mock_shuffle_switch_id = switch.ENTITY_ID_FORMAT.format("shuffle")
        self.hass.states.set(self.mock_shuffle_switch_id, STATE_OFF)

        self.mock_repeat_switch_id = switch.ENTITY_ID_FORMAT.format("repeat")
        self.hass.states.set(self.mock_repeat_switch_id, STATE_OFF)

        self.config_children_only = {
            "name": "test",
            "platform": "universal",
            "children": [
                media_player.ENTITY_ID_FORMAT.format("mock1"),
                media_player.ENTITY_ID_FORMAT.format("mock2"),
            ],
        }
        self.config_children_and_attr = {
            "name": "test",
            "platform": "universal",
            "children": [
                media_player.ENTITY_ID_FORMAT.format("mock1"),
                media_player.ENTITY_ID_FORMAT.format("mock2"),
            ],
            "attributes": {
                "is_volume_muted": self.mock_mute_switch_id,
                "volume_level": self.mock_volume_id,
                "source": self.mock_source_id,
                "source_list": self.mock_source_list_id,
                "state": self.mock_state_switch_id,
                "shuffle": self.mock_shuffle_switch_id,
                "repeat": self.mock_repeat_switch_id,
                "sound_mode_list": self.mock_sound_mode_list_id,
                "sound_mode": self.mock_sound_mode_id,
            },
        }
        self.addCleanup(self.tear_down_cleanup)
Esempio n. 60
0
 def setUp(self):  # pylint: disable=invalid-name
     """Set up things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     mock_mqtt_client(self.hass)
     self.calls = []