def test_component_not_installed_if_requirement_fails(self, mock_install): """Component setup should fail if requirement can't install.""" loader.set_component( 'comp', MockModule('comp', requirements=['package==0.0.1'])) assert not bootstrap.setup_component(self.hass, 'comp') assert 'comp' not in self.hass.config.components
def test_component_failing_setup(self): """Test component that fails setup.""" loader.set_component( 'comp', MockModule('comp', setup=lambda hass, config: False)) assert not bootstrap._setup_component(self.hass, 'comp', None) assert 'comp' not in self.hass.config.components
def test_validate_component_config(self): """Test validating component configuration.""" config_schema = vol.Schema({ 'comp_conf': { 'hello': str } }, required=True) loader.set_component( 'comp_conf', MockModule('comp_conf', config_schema=config_schema)) assert not bootstrap._setup_component(self.hass, 'comp_conf', {}) assert not bootstrap._setup_component(self.hass, 'comp_conf', { 'comp_conf': None }) assert not bootstrap._setup_component(self.hass, 'comp_conf', { 'comp_conf': {} }) assert not bootstrap._setup_component(self.hass, 'comp_conf', { 'comp_conf': { 'hello': 'world', 'invalid': 'extra', } }) assert bootstrap._setup_component(self.hass, 'comp_conf', { 'comp_conf': { 'hello': 'world', } })
def test_platform_specific_config_validation(self): """Test platform that specifies config.""" platform_schema = PLATFORM_SCHEMA.extend({ 'valid': True, }, extra=vol.PREVENT_EXTRA) loader.set_component( 'switch.platform_a', MockPlatform('comp_b', platform_schema=platform_schema)) assert not bootstrap.setup_component( self.hass, 'switch', {'switch': { 'platform': 'platform_a', 'invalid': True }}) assert not bootstrap.setup_component( self.hass, 'switch', { 'switch': { 'platform': 'platform_a', 'valid': True, 'invalid_extra': True, } }) assert bootstrap.setup_component( self.hass, 'switch', {'switch': { 'platform': 'platform_a', 'valid': True }})
def test_platform_specific_config_validation(self): """Test platform that specifies config.""" platform_schema = PLATFORM_SCHEMA.extend({ 'valid': True, }, extra=vol.PREVENT_EXTRA) loader.set_component( 'switch.platform_a', MockPlatform('comp_b', platform_schema=platform_schema)) assert not bootstrap.setup_component(self.hass, 'switch', { 'switch': { 'platform': 'platform_a', 'invalid': True } }) assert not bootstrap.setup_component(self.hass, 'switch', { 'switch': { 'platform': 'platform_a', 'valid': True, 'invalid_extra': True, } }) assert bootstrap.setup_component(self.hass, 'switch', { 'switch': { 'platform': 'platform_a', 'valid': True } })
def test_setup_recovers_when_setup_raises(self): """Test the setup if exceptions are happening.""" platform1_setup = Mock(side_effect=Exception('Broken')) platform2_setup = Mock(return_value=None) loader.set_component('test_domain.mod1', MockPlatform(platform1_setup)) loader.set_component('test_domain.mod2', MockPlatform(platform2_setup)) component = EntityComponent(_LOGGER, DOMAIN, self.hass) assert not platform1_setup.called assert not platform2_setup.called component.setup( OrderedDict([ (DOMAIN, { 'platform': 'mod1' }), ("{} 2".format(DOMAIN), { 'platform': 'non_exist' }), ("{} 3".format(DOMAIN), { 'platform': 'mod2' }), ])) assert platform1_setup.called assert platform2_setup.called
def test_validate_component_config(self): """Test validating component configuration.""" config_schema = vol.Schema({'comp_conf': { 'hello': str }}, required=True) loader.set_component( 'comp_conf', MockModule('comp_conf', config_schema=config_schema)) assert not bootstrap._setup_component(self.hass, 'comp_conf', {}) assert not bootstrap._setup_component(self.hass, 'comp_conf', {'comp_conf': None}) assert not bootstrap._setup_component(self.hass, 'comp_conf', {'comp_conf': {}}) assert not bootstrap._setup_component( self.hass, 'comp_conf', {'comp_conf': { 'hello': 'world', 'invalid': 'extra', }}) assert bootstrap._setup_component(self.hass, 'comp_conf', {'comp_conf': { 'hello': 'world', }})
def test_validate_platform_config(self): """Test validating platform configuration.""" platform_schema = PLATFORM_SCHEMA.extend({ 'hello': str, }) loader.set_component( 'platform_conf', MockModule('platform_conf', platform_schema=platform_schema)) loader.set_component( 'platform_conf.whatever', MockPlatform('whatever')) assert not bootstrap._setup_component(self.hass, 'platform_conf', { 'platform_conf': None }) assert not bootstrap._setup_component(self.hass, 'platform_conf', { 'platform_conf': {} }) assert not bootstrap._setup_component(self.hass, 'platform_conf', { 'platform_conf': { 'hello': 'world', 'invalid': 'extra', } }) assert not bootstrap._setup_component(self.hass, 'platform_conf', { 'platform_conf': { 'platform': 'whatever', 'hello': 'world', }, 'platform_conf 2': { 'invalid': True } }) assert not bootstrap._setup_component(self.hass, 'platform_conf', { 'platform_conf': { 'platform': 'not_existing', 'hello': 'world', } }) assert bootstrap._setup_component(self.hass, 'platform_conf', { 'platform_conf': { 'platform': 'whatever', 'hello': 'world', } }) assert bootstrap._setup_component(self.hass, 'platform_conf', { 'platform_conf': [{ 'platform': 'whatever', 'hello': 'world', }] })
def test_validate_platform_config(self): """Test validating platform configuration.""" platform_schema = PLATFORM_SCHEMA.extend({ 'hello': str, }) loader.set_component( 'platform_conf', MockModule('platform_conf', platform_schema=platform_schema)) loader.set_component('platform_conf.whatever', MockPlatform('whatever')) assert not bootstrap._setup_component(self.hass, 'platform_conf', {'platform_conf': None}) assert not bootstrap._setup_component(self.hass, 'platform_conf', {'platform_conf': {}}) assert not bootstrap._setup_component( self.hass, 'platform_conf', {'platform_conf': { 'hello': 'world', 'invalid': 'extra', }}) assert not bootstrap._setup_component( self.hass, 'platform_conf', { 'platform_conf': { 'platform': 'whatever', 'hello': 'world', }, 'platform_conf 2': { 'invalid': True } }) assert not bootstrap._setup_component(self.hass, 'platform_conf', { 'platform_conf': { 'platform': 'not_existing', 'hello': 'world', } }) assert bootstrap._setup_component( self.hass, 'platform_conf', {'platform_conf': { 'platform': 'whatever', 'hello': 'world', }}) assert bootstrap._setup_component( self.hass, 'platform_conf', {'platform_conf': [{ 'platform': 'whatever', 'hello': 'world', }]})
def test_component_exception_setup(self): """Test component that raises exception during setup.""" def exception_setup(hass, config): """Setup that raises exception.""" raise Exception('fail!') loader.set_component('comp', MockModule('comp', setup=exception_setup)) assert not bootstrap._setup_component(self.hass, 'comp', None) assert 'comp' not in self.hass.config.components
def test_component_not_setup_missing_dependencies(self): """Test we do not setup a component if not all dependencies loaded.""" deps = ['non_existing'] loader.set_component('comp', MockModule('comp', dependencies=deps)) assert not bootstrap._setup_component(self.hass, 'comp', None) assert 'comp' not in self.hass.config.components self.hass.config.components.append('non_existing') assert bootstrap._setup_component(self.hass, 'comp', None)
def test_handle_setup_circular_dependency(self): """Test the setup of circular dependencies.""" loader.set_component('comp_b', MockModule('comp_b', ['comp_a'])) def setup_a(hass, config): """Setup the another component.""" bootstrap.setup_component(hass, 'comp_b') return True loader.set_component('comp_a', MockModule('comp_a', setup=setup_a)) bootstrap.setup_component(self.hass, 'comp_a') assert ['comp_a'] == self.hass.config.components
def test_component_not_double_initialized(self): """Test we do not setup a component twice.""" mock_setup = mock.MagicMock() loader.set_component('comp', MockModule('comp', setup=mock_setup)) assert bootstrap.setup_component(self.hass, 'comp') assert mock_setup.called mock_setup.reset_mock() assert bootstrap.setup_component(self.hass, 'comp') assert not mock_setup.called
def test_setup_two_platforms(self): """Test with bad configuration.""" # Test if switch component returns 0 switches test_platform = loader.get_component('switch.test') test_platform.init(True) loader.set_component('switch.test2', test_platform) test_platform.init(False) self.assertTrue(switch.setup( self.hass, { switch.DOMAIN: {CONF_PLATFORM: 'test'}, '{} 2'.format(switch.DOMAIN): {CONF_PLATFORM: 'test2'}, } ))
def test_set_scan_interval_via_platform(self, mock_track): """Test the setting of the scan interval via platform.""" def platform_setup(hass, config, add_devices, discovery_info=None): """Test the platform setup.""" add_devices([EntityTest(should_poll=True)]) platform = MockPlatform(platform_setup) platform.SCAN_INTERVAL = 30 loader.set_component('test_domain.platform', platform) component = EntityComponent(_LOGGER, DOMAIN, self.hass) component.setup({DOMAIN: { 'platform': 'platform', }}) assert mock_track.called assert [0, 30] == list(mock_track.call_args[1]['second'])
def test_set_scan_interval_via_config(self, mock_track): """Test the setting of the scan interval via configuration.""" def platform_setup(hass, config, add_devices, discovery_info=None): """Test the platform setup.""" add_devices([EntityTest(should_poll=True)]) loader.set_component('test_domain.platform', MockPlatform(platform_setup)) component = EntityComponent(_LOGGER, DOMAIN, self.hass) component.setup({ DOMAIN: { 'platform': 'platform', 'scan_interval': 30, } }) assert mock_track.called assert [0, 30] == list(mock_track.call_args[1]['second'])
def test_setup_loads_platforms(self): """Test the loading of the platforms.""" component_setup = Mock(return_value=True) platform_setup = Mock(return_value=None) loader.set_component( 'test_component', MockModule('test_component', setup=component_setup)) loader.set_component('test_domain.mod2', MockPlatform(platform_setup, ['test_component'])) component = EntityComponent(_LOGGER, DOMAIN, self.hass) assert not component_setup.called assert not platform_setup.called component.setup({DOMAIN: { 'platform': 'mod2', }}) assert component_setup.called assert platform_setup.called
def test_load_order_component(self): """Test if we can get the proper load order of components.""" loader.set_component('mod1', MockModule('mod1')) loader.set_component('mod2', MockModule('mod2', ['mod1'])) loader.set_component('mod3', MockModule('mod3', ['mod2'])) self.assertEqual( ['mod1', 'mod2', 'mod3'], loader.load_order_component('mod3')) # Create circular dependency loader.set_component('mod1', MockModule('mod1', ['mod3'])) self.assertEqual([], loader.load_order_component('mod3')) # Depend on non-existing component loader.set_component('mod1', MockModule('mod1', ['nonexisting'])) self.assertEqual([], loader.load_order_component('mod1')) # Try to get load order for non-existing component self.assertEqual([], loader.load_order_component('mod1'))
def test_setup_recovers_when_setup_raises(self): """Test the setup if exceptions are happening.""" platform1_setup = Mock(side_effect=Exception('Broken')) platform2_setup = Mock(return_value=None) loader.set_component('test_domain.mod1', MockPlatform(platform1_setup)) loader.set_component('test_domain.mod2', MockPlatform(platform2_setup)) component = EntityComponent(_LOGGER, DOMAIN, self.hass) assert not platform1_setup.called assert not platform2_setup.called component.setup(OrderedDict([ (DOMAIN, {'platform': 'mod1'}), ("{} 2".format(DOMAIN), {'platform': 'non_exist'}), ("{} 3".format(DOMAIN), {'platform': 'mod2'}), ])) assert platform1_setup.called assert platform2_setup.called
def test_component_not_setup_twice_if_loaded_during_other_setup(self): """ Test component that gets setup while waiting for lock is not setup twice. """ loader.set_component('comp', MockModule('comp')) result = [] def setup_component(): result.append(bootstrap.setup_component(self.hass, 'comp')) with bootstrap._SETUP_LOCK: thread = threading.Thread(target=setup_component) thread.start() self.hass.config.components.append('comp') thread.join() assert len(result) == 1 assert result[0]
def test_setup_loads_platforms(self): """Test the loading of the platforms.""" component_setup = Mock(return_value=True) platform_setup = Mock(return_value=None) loader.set_component( 'test_component', MockModule('test_component', setup=component_setup)) loader.set_component('test_domain.mod2', MockPlatform(platform_setup, ['test_component'])) component = EntityComponent(_LOGGER, DOMAIN, self.hass) assert not component_setup.called assert not platform_setup.called component.setup({ DOMAIN: { 'platform': 'mod2', } }) assert component_setup.called assert platform_setup.called
def test_component_setup_with_validation_and_dependency(self): """Test all config is passed to dependencies.""" def config_check_setup(hass, config): """Setup method that tests config is passed in.""" if config.get('comp_a', {}).get('valid', False): return True raise Exception('Config not passed in: {}'.format(config)) loader.set_component('comp_a', MockModule('comp_a', setup=config_check_setup)) loader.set_component('switch.platform_a', MockPlatform('comp_b', ['comp_a'])) bootstrap.setup_component(self.hass, 'switch', { 'comp_a': { 'valid': True }, 'switch': { 'platform': 'platform_a', } }) assert 'comp_a' in self.hass.config.components
def test_set_entity_namespace_via_config(self): """Test setting an entity namespace.""" def platform_setup(hass, config, add_devices, discovery_info=None): """Test the platform setup.""" add_devices([ EntityTest(name='beer'), EntityTest(name=None), ]) platform = MockPlatform(platform_setup) loader.set_component('test_domain.platform', platform) component = EntityComponent(_LOGGER, DOMAIN, self.hass) component.setup( {DOMAIN: { 'platform': 'platform', 'entity_namespace': 'yummy' }}) assert sorted(self.hass.states.entity_ids()) == \ ['test_domain.yummy_beer', 'test_domain.yummy_unnamed_device']
def test_set_entity_namespace_via_config(self): """Test setting an entity namespace.""" def platform_setup(hass, config, add_devices, discovery_info=None): """Test the platform setup.""" add_devices([ EntityTest(name='beer'), EntityTest(name=None), ]) platform = MockPlatform(platform_setup) loader.set_component('test_domain.platform', platform) component = EntityComponent(_LOGGER, DOMAIN, self.hass) component.setup({ DOMAIN: { 'platform': 'platform', 'entity_namespace': 'yummy' } }) assert sorted(self.hass.states.entity_ids()) == \ ['test_domain.yummy_beer', 'test_domain.yummy_unnamed_device']
def test_set_component(self): """Test if set_component works.""" loader.set_component('switch.test_set', http) self.assertEqual(http, loader.get_component('switch.test_set'))
def test_load_order_components(self): """Setup loading order of components.""" loader.set_component('mod1', MockModule('mod1', ['group'])) loader.set_component('mod2', MockModule('mod2', ['mod1', 'sun'])) loader.set_component('mod3', MockModule('mod3', ['mod2'])) loader.set_component('mod4', MockModule('mod4', ['group'])) self.assertEqual( ['group', 'mod4', 'mod1', 'sun', 'mod2', 'mod3'], loader.load_order_components(['mod4', 'mod3', 'mod2'])) loader.set_component('mod1', MockModule('mod1')) loader.set_component('mod2', MockModule('mod2', ['group'])) self.assertEqual( ['mod1', 'group', 'mod2'], loader.load_order_components(['mod2', 'mod1'])) # Add a non existing one self.assertEqual( ['mod1', 'group', 'mod2'], loader.load_order_components(['mod2', 'nonexisting', 'mod1'])) # Depend on a non existing one loader.set_component('mod1', MockModule('mod1', ['nonexisting'])) self.assertEqual( ['group', 'mod2'], loader.load_order_components(['mod2', 'mod1']))