Python common.get_test_config_dir函数代码示例

    def test_config_component_platform_fail_validation(self):
        """Test errors if component & platform not found."""
        files = {
            'component.yaml': BASE_CONFIG + 'http:\n  password: err123',
        }
        with patch_yaml_files(files):
            res = check_config.check(get_test_config_dir('component.yaml'))
            change_yaml_files(res)
            self.assertDictEqual({
                'components': {},
                'except': {'http': {'password': 'err123'}},
                'secret_cache': {},
                'secrets': {},
                'yaml_files': ['.../component.yaml']
            }, res)

        files = {
            'platform.yaml': (BASE_CONFIG + 'mqtt:\n\n'
                              'light:\n  platform: mqtt_json'),
        }
        with patch_yaml_files(files):
            res = check_config.check(get_test_config_dir('platform.yaml'))
            change_yaml_files(res)
            self.assertDictEqual({
                'components': {'mqtt': {'keepalive': 60, 'port': 1883,
                                        'protocol': '3.1.1'}},
                'except': {'light.mqtt_json': {'platform': 'mqtt_json'}},
                'secret_cache': {},
                'secrets': {},
                'yaml_files': ['.../platform.yaml']
            }, res)

    def test_component_platform_not_found(self, isfile_patch):
        """Test errors if component or platform not found."""
        # Make sure they don't exist
        set_component('beer', None)
        files = {
            YAML_CONFIG_FILE: BASE_CONFIG + 'beer:',
        }
        with patch_yaml_files(files):
            res = check_config.check(get_test_config_dir())
            assert res['components'].keys() == {'homeassistant'}
            assert res['except'] == {
                check_config.ERROR_STR: ['Component not found: beer']}
            assert res['secret_cache'] == {}
            assert res['secrets'] == {}
            assert len(res['yaml_files']) == 1

        set_component('light.beer', None)
        files = {
            YAML_CONFIG_FILE: BASE_CONFIG + 'light:\n  platform: beer',
        }
        with patch_yaml_files(files):
            res = check_config.check(get_test_config_dir())
            assert res['components'].keys() == {'homeassistant', 'light'}
            assert res['components']['light'] == []
            assert res['except'] == {
                check_config.ERROR_STR: [
                    'Platform not found: light.beer',
                ]}
            assert res['secret_cache'] == {}
            assert res['secrets'] == {}
            assert len(res['yaml_files']) == 1

    def test_setup_with_multiple_hosts(self, mock_phue):
        """Multiple hosts specified in the config file."""
        mock_bridge = mock_phue.Bridge

        with assert_setup_component(1):
            with patch('homeassistant.helpers.discovery.load_platform') \
                    as mock_load:
                self.assertTrue(setup_component(
                    self.hass, hue.DOMAIN,
                    {hue.DOMAIN: {hue.CONF_BRIDGES: [
                        {CONF_HOST: 'localhost'},
                        {CONF_HOST: '192.168.0.1'}]}}))

                mock_bridge.assert_has_calls([
                    call(
                        'localhost',
                        config_file_path=get_test_config_dir(
                            hue.PHUE_CONFIG_FILE)),
                    call(
                        '192.168.0.1',
                        config_file_path=get_test_config_dir(
                            hue.PHUE_CONFIG_FILE))])
                mock_load.mock_bridge.assert_not_called()
                mock_load.assert_has_calls([
                    call(
                        self.hass, 'light', hue.DOMAIN,
                        {'bridge_id': '127.0.0.1'}),
                    call(
                        self.hass, 'light', hue.DOMAIN,
                        {'bridge_id': '192.168.0.1'}),
                ], any_order=True)

                self.assertTrue(hue.DOMAIN in self.hass.data)
                self.assertEqual(2, len(self.hass.data[hue.DOMAIN]))

    def test_component_platform_not_found(self, mock_get_loop):
        """Test errors if component or platform not found."""
        files = {
            'badcomponent.yaml': BASE_CONFIG + 'beer:',
            'badplatform.yaml': BASE_CONFIG + 'light:\n  platform: beer',
        }
        with patch_yaml_files(files):
            res = check_config.check(get_test_config_dir('badcomponent.yaml'))
            change_yaml_files(res)
            self.assertDictEqual({}, res['components'])
            self.assertDictEqual({check_config.ERROR_STR:
                                  ['Component not found: beer']},
                                 res['except'])
            self.assertDictEqual({}, res['secret_cache'])
            self.assertDictEqual({}, res['secrets'])
            self.assertListEqual(['.../badcomponent.yaml'], res['yaml_files'])

            res = check_config.check(get_test_config_dir('badplatform.yaml'))
            change_yaml_files(res)
            self.assertDictEqual({'light': []}, res['components'])
            self.assertDictEqual({check_config.ERROR_STR:
                                  ['Platform not found: light.beer']},
                                 res['except'])
            self.assertDictEqual({}, res['secret_cache'])
            self.assertDictEqual({}, res['secrets'])
            self.assertListEqual(['.../badplatform.yaml'], res['yaml_files'])

    def test_secrets(self, mock_get_loop):
        """Test secrets config checking method."""
        files = {
            get_test_config_dir('secret.yaml'): (
                BASE_CONFIG +
                'http:\n'
                '  api_password: !secret http_pw'),
            'secrets.yaml': ('logger: debug\n'
                             'http_pw: abc123'),
        }
        self.maxDiff = None

        with patch_yaml_files(files):
            config_path = get_test_config_dir('secret.yaml')
            secrets_path = get_test_config_dir('secrets.yaml')

            res = check_config.check(config_path)
            change_yaml_files(res)

            # convert secrets OrderedDict to dict for assertequal
            for key, val in res['secret_cache'].items():
                res['secret_cache'][key] = dict(val)

            self.assertDictEqual({
                'components': {'http': {'api_password': 'abc123',
                                        'server_port': 8123}},
                'except': {},
                'secret_cache': {secrets_path: {'http_pw': 'abc123'}},
                'secrets': {'http_pw': 'abc123'},
                'yaml_files': ['.../secret.yaml', '.../secrets.yaml']
            }, res)

    def test_component_platform_not_found(self):
        """Test errors if component or platform not found."""
        # Make sure they don't exist
        set_component('beer', None)
        set_component('light.beer', None)
        files = {
            'badcomponent.yaml': BASE_CONFIG + 'beer:',
            'badplatform.yaml': BASE_CONFIG + 'light:\n  platform: beer',
        }
        with patch_yaml_files(files):
            res = check_config.check(get_test_config_dir('badcomponent.yaml'))
            change_yaml_files(res)
            self.assertDictEqual({}, res['components'])
            self.assertDictEqual({
                    check_config.ERROR_STR: [
                        'Component not found: beer',
                        'Setup failed for beer: Component not found.']
                }, res['except'])
            self.assertDictEqual({}, res['secret_cache'])
            self.assertDictEqual({}, res['secrets'])
            self.assertListEqual(['.../badcomponent.yaml'], res['yaml_files'])

            res = check_config.check(get_test_config_dir('badplatform.yaml'))
            change_yaml_files(res)
            assert res['components'] == {'light': [], 'group': None}
            assert res['except'] == {
                check_config.ERROR_STR: [
                    'Platform not found: light.beer',
                ]}
            self.assertDictEqual({}, res['secret_cache'])
            self.assertDictEqual({}, res['secrets'])
            self.assertListEqual(['.../badplatform.yaml'], res['yaml_files'])

    def test_secrets(self, isfile_patch):
        """Test secrets config checking method."""
        secrets_path = get_test_config_dir('secrets.yaml')

        files = {
            get_test_config_dir(YAML_CONFIG_FILE): BASE_CONFIG + (
                'http:\n'
                '  api_password: !secret http_pw'),
            secrets_path: (
                'logger: debug\n'
                'http_pw: abc123'),
        }

        with patch_yaml_files(files):

            res = check_config.check(get_test_config_dir(), True)

            assert res['except'] == {}
            assert res['components'].keys() == {'homeassistant', 'http'}
            assert res['components']['http'] == {
                'api_password': 'abc123',
                'cors_allowed_origins': [],
                'ip_ban_enabled': True,
                'login_attempts_threshold': -1,
                'server_host': '0.0.0.0',
                'server_port': 8123,
                'trusted_networks': [],
                'use_x_forwarded_for': False}
            assert res['secret_cache'] == {secrets_path: {'http_pw': 'abc123'}}
            assert res['secrets'] == {'http_pw': 'abc123'}
            assert normalize_yaml_files(res) == [
                '.../configuration.yaml', '.../secrets.yaml']

    def test_setup_with_phue_conf(self, mock_phue):
        """No host in the config file, but one is cached in phue.conf."""
        mock_bridge = mock_phue.Bridge

        with assert_setup_component(1):
            with patch(
                    'homeassistant.components.hue._find_host_from_config',
                    return_value='localhost'):
                with patch('homeassistant.helpers.discovery.load_platform') \
                        as mock_load:
                    self.assertTrue(setup_component(
                        self.hass, hue.DOMAIN,
                        {hue.DOMAIN: {hue.CONF_BRIDGES: [
                            {CONF_FILENAME: 'phue.conf'}]}}))

                    mock_bridge.assert_called_once_with(
                        'localhost',
                        config_file_path=get_test_config_dir(
                            hue.PHUE_CONFIG_FILE))
                    mock_load.assert_called_once_with(
                        self.hass, 'light', hue.DOMAIN,
                        {'bridge_id': '127.0.0.1'})

                    self.assertTrue(hue.DOMAIN in self.hass.data)
                    self.assertEqual(1, len(self.hass.data[hue.DOMAIN]))

    def test_setup_bridge_registration_succeeds(self, mock_phue):
        """Test a registration success sequence."""
        mock_bridge = mock_phue.Bridge
        mock_phue.PhueRegistrationException = Exception
        mock_bridge.side_effect = [
            # First call, raise because not registered
            mock_phue.PhueRegistrationException(1, 2),
            # Second call, registration is done
            None,
        ]

        bridge = hue.HueBridge(
            'localhost', self.hass, hue.PHUE_CONFIG_FILE, None)
        bridge.setup()
        self.assertFalse(bridge.configured)
        self.assertFalse(bridge.config_request_id is None)

        # Simulate the user confirming the registration
        self.hass.services.call(
            configurator.DOMAIN, configurator.SERVICE_CONFIGURE,
            {configurator.ATTR_CONFIGURE_ID: bridge.config_request_id})

        self.hass.block_till_done()
        self.assertTrue(bridge.configured)
        self.assertTrue(bridge.config_request_id is None)

        # We should see a total of two identical calls
        args = call(
            'localhost',
            config_file_path=get_test_config_dir(hue.PHUE_CONFIG_FILE))
        mock_bridge.assert_has_calls([args, args])

        # Make sure the request is done
        self.assertEqual(1, len(self.hass.states.all()))
        self.assertEqual('configured', self.hass.states.all()[0].state)

    def setUp(self):  # pylint: disable=invalid-name
        """Create & load secrets file."""
        config_dir = get_test_config_dir()
        yaml.clear_secret_cache()
        self._yaml_path = os.path.join(config_dir,
                                       config_util.YAML_CONFIG_FILE)
        self._secret_path = os.path.join(config_dir, yaml._SECRET_YAML)
        self._sub_folder_path = os.path.join(config_dir, 'subFolder')
        if not os.path.exists(self._sub_folder_path):
            os.makedirs(self._sub_folder_path)
        self._unrelated_path = os.path.join(config_dir, 'unrelated')
        if not os.path.exists(self._unrelated_path):
            os.makedirs(self._unrelated_path)

        load_yaml(self._secret_path,
                  'http_pw: pwhttp\n'
                  'comp1_un: un1\n'
                  'comp1_pw: pw1\n'
                  'stale_pw: not_used\n'
                  'logger: debug\n')
        self._yaml = load_yaml(self._yaml_path,
                               'http:\n'
                               '  api_password: !secret http_pw\n'
                               'component:\n'
                               '  username: !secret comp1_un\n'
                               '  password: !secret comp1_pw\n'
                               '')

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 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
    slave = remote.HomeAssistant(master_api)
    slave.config.config_dir = get_test_config_dir()
    bootstrap.setup_component(
        slave, http.DOMAIN, {http.DOMAIN: {http.CONF_API_PASSWORD: API_PASSWORD, http.CONF_SERVER_PORT: SLAVE_PORT}}
    )

    slave.start()

    def test_config_component_platform_fail_validation(self):
        """Test errors if component & platform not found."""
        files = {
            'component.yaml': BASE_CONFIG + 'http:\n  password: err123',
        }
        with patch_yaml_files(files):
            res = check_config.check(get_test_config_dir('component.yaml'))
            change_yaml_files(res)

            self.assertDictEqual({}, res['components'])
            res['except'].pop(check_config.ERROR_STR)
            self.assertDictEqual(
                {'http': {'password': 'err123'}},
                res['except']
            )
            self.assertDictEqual({}, res['secret_cache'])
            self.assertDictEqual({}, res['secrets'])
            self.assertListEqual(['.../component.yaml'], res['yaml_files'])

        files = {
            'platform.yaml': (BASE_CONFIG + 'mqtt:\n\n'
                              'light:\n  platform: mqtt_json'),
        }
        with patch_yaml_files(files):
            res = check_config.check(get_test_config_dir('platform.yaml'))
            change_yaml_files(res)
            self.assertDictEqual(
                {'mqtt': {
                    'keepalive': 60,
                    'port': 1883,
                    'protocol': '3.1.1',
                    'discovery': False,
                    'discovery_prefix': 'homeassistant',
                    'tls_version': 'auto',
                },
                 'light': [],
                 'group': None},
                res['components']
            )
            self.assertDictEqual(
                {'light.mqtt_json': {'platform': 'mqtt_json'}},
                res['except']
            )
            self.assertDictEqual({}, res['secret_cache'])
            self.assertDictEqual({}, res['secrets'])
            self.assertListEqual(['.../platform.yaml'], res['yaml_files'])

 def test_bad_core_config(self, isfile_patch):
     """Test a bad core config setup."""
     files = {
         YAML_CONFIG_FILE: BAD_CORE_CONFIG,
     }
     with patch_yaml_files(files):
         res = check_config.check(get_test_config_dir())
         assert res['except'].keys() == {'homeassistant'}
         assert res['except']['homeassistant'][1] == {'unit_system': 'bad'}

 def setUp(self):
     """Initialize values for this testcase class."""
     self.hass = get_test_home_assistant()
     self.cache = get_test_config_dir(base_ring.DEFAULT_CACHEDB)
     self.config = {
         'username': 'foo',
         'password': 'bar',
         'monitored_conditions': ['ding', 'motion'],
     }