text: """Test component/platform setup."""
  # pylint: disable=protected-access
  import asyncio
  import os
  from unittest import mock
  import threading
  import logging
  
  import voluptuous as vol
  
  from homeassistant.core import callback
  from homeassistant.const import EVENT_HOMEASSISTANT_START, EVENT_COMPONENT_LOADED
  import homeassistant.config as config_util
  from homeassistant import setup
  import homeassistant.util.dt as dt_util
  from homeassistant.helpers.config_validation import (
      PLATFORM_SCHEMA,
      PLATFORM_SCHEMA_BASE,
  )
  from homeassistant.helpers import discovery
  
  from tests.common import (
      get_test_home_assistant,
      MockModule,
      MockPlatform,
      assert_setup_component,
      get_test_config_dir,
      mock_integration,
      mock_entity_platform,
  )
  
  ORIG_TIMEZONE = dt_util.DEFAULT_TIME_ZONE
  VERSION_PATH = os.path.join(get_test_config_dir(), config_util.VERSION_FILE)
  
  _LOGGER = logging.getLogger(__name__)
  
  
  class TestSetup:
      """Test the bootstrap utils."""
  
      hass = None
      backup_cache = None
  
      # pylint: disable=invalid-name, no-self-use
      def setup_method(self, method):
          """Set up the test."""
          self.hass = get_test_home_assistant()
  
      def teardown_method(self, method):
          """Clean up."""
          self.hass.stop()
  
      def test_validate_component_config(self):
          """Test validating component configuration."""
          config_schema = vol.Schema({"comp_conf": {"hello": str}}, required=True)
          mock_integration(
              self.hass, MockModule("comp_conf", config_schema=config_schema)
          )
  
          with assert_setup_component(0):
              assert not setup.setup_component(self.hass, "comp_conf", {})
  
          self.hass.data.pop(setup.DATA_SETUP)
  
          with assert_setup_component(0):
              assert not setup.setup_component(
                  self.hass, "comp_conf", {"comp_conf": None}
              )
  
          self.hass.data.pop(setup.DATA_SETUP)
  
          with assert_setup_component(0):
              assert not setup.setup_component(self.hass, "comp_conf", {"comp_conf": {}})
  
          self.hass.data.pop(setup.DATA_SETUP)
  
          with assert_setup_component(0):
              assert not setup.setup_component(
                  self.hass,
                  "comp_conf",
                  {"comp_conf": {"hello": "world", "invalid": "extra"}},
              )
  
          self.hass.data.pop(setup.DATA_SETUP)
  
          with assert_setup_component(1):
              assert setup.setup_component(
                  self.hass, "comp_conf", {"comp_conf": {"hello": "world"}}
              )
  
      def test_validate_platform_config(self, caplog):
          """Test validating platform configuration."""
          platform_schema = PLATFORM_SCHEMA.extend({"hello": str})
          platform_schema_base = PLATFORM_SCHEMA_BASE.extend({})
          mock_integration(
              self.hass,
              MockModule("platform_conf", platform_schema_base=platform_schema_base),
          )
          mock_entity_platform(
              self.hass,
              "platform_conf.whatever",
              MockPlatform(platform_schema=platform_schema),
          )
  
          with assert_setup_component(0):
              assert setup.setup_component(
                  self.hass,
                  "platform_conf",
                  {"platform_conf": {"platform": "not_existing", "hello": "world"}},
              )
  
          self.hass.data.pop(setup.DATA_SETUP)
          self.hass.config.components.remove("platform_conf")
  
          with assert_setup_component(1):
              assert setup.setup_component(
                  self.hass,
                  "platform_conf",
                  {"platform_conf": {"platform": "whatever", "hello": "world"}},
              )
  
          self.hass.data.pop(setup.DATA_SETUP)
          self.hass.config.components.remove("platform_conf")
  
          with assert_setup_component(1):
              assert setup.setup_component(
                  self.hass,
                  "platform_conf",
                  {"platform_conf": [{"platform": "whatever", "hello": "world"}]},
              )
  
          self.hass.data.pop(setup.DATA_SETUP)
          self.hass.config.components.remove("platform_conf")
  
          # Any falsey platform config will be ignored (None, {}, etc)
          with assert_setup_component(0) as config:
              assert setup.setup_component(
                  self.hass, "platform_conf", {"platform_conf": None}
              )
              assert "platform_conf" in self.hass.config.components
              assert not config["platform_conf"]  # empty
  
              assert setup.setup_component(
                  self.hass, "platform_conf", {"platform_conf": {}}
              )
              assert "platform_conf" in self.hass.config.components
              assert not config["platform_conf"]  # empty
  
      def test_validate_platform_config_2(self, caplog):
          """Test component PLATFORM_SCHEMA_BASE prio over PLATFORM_SCHEMA."""
          platform_schema = PLATFORM_SCHEMA.extend({"hello": str})
          platform_schema_base = PLATFORM_SCHEMA_BASE.extend({"hello": "world"})
          mock_integration(
              self.hass,
              MockModule(
                  "platform_conf",
                  platform_schema=platform_schema,
                  platform_schema_base=platform_schema_base,
              ),
          )
  
          mock_entity_platform(
              self.hass,
              "platform_conf.whatever",
              MockPlatform("whatever", platform_schema=platform_schema),
          )
  
          with assert_setup_component(1):
              assert setup.setup_component(
                  self.hass,
                  "platform_conf",
                  {
                      # pass
                      "platform_conf": {"platform": "whatever", "hello": "world"},
                      # fail: key hello violates component platform_schema_base
                      "platform_conf 2": {"platform": "whatever", "hello": "there"},
                  },
              )
  
      def test_validate_platform_config_3(self, caplog):
          """Test fallback to component PLATFORM_SCHEMA."""
          component_schema = PLATFORM_SCHEMA_BASE.extend({"hello": str})
          platform_schema = PLATFORM_SCHEMA.extend({"cheers": str, "hello": "world"})
          mock_integration(
              self.hass, MockModule("platform_conf", platform_schema=component_schema)
          )
  
          mock_entity_platform(
              self.hass,
              "platform_conf.whatever",
              MockPlatform("whatever", platform_schema=platform_schema),
          )
  
          with assert_setup_component(1):
              assert setup.setup_component(
                  self.hass,
                  "platform_conf",
                  {
                      # pass
                      "platform_conf": {"platform": "whatever", "hello": "world"},
                      # fail: key hello violates component platform_schema
                      "platform_conf 2": {"platform": "whatever", "hello": "there"},
                  },
              )
  
      def test_validate_platform_config_4(self):
          """Test entity_namespace in PLATFORM_SCHEMA."""
          component_schema = PLATFORM_SCHEMA_BASE
          platform_schema = PLATFORM_SCHEMA
          mock_integration(
              self.hass,
              MockModule("platform_conf", platform_schema_base=component_schema),
          )
  
          mock_entity_platform(
              self.hass,
              "platform_conf.whatever",
              MockPlatform(platform_schema=platform_schema),
          )
  
          with assert_setup_component(1):
              assert setup.setup_component(
                  self.hass,
                  "platform_conf",
                  {
                      "platform_conf": {
                          # pass: entity_namespace accepted by PLATFORM_SCHEMA
                          "platform": "whatever",
                          "entity_namespace": "yummy",
                      }
                  },
              )
  
          self.hass.data.pop(setup.DATA_SETUP)
          self.hass.config.components.remove("platform_conf")
  
      def test_component_not_found(self):
          """setup_component should not crash if component doesn't exist."""
          assert setup.setup_component(self.hass, "non_existing", {}) is False
  
      def test_component_not_double_initialized(self):
          """Test we do not set up a component twice."""
          mock_setup = mock.MagicMock(return_value=True)
  
          mock_integration(self.hass, MockModule("comp", setup=mock_setup))
  
          assert setup.setup_component(self.hass, "comp", {})
          assert mock_setup.called
  
          mock_setup.reset_mock()
  
          assert setup.setup_component(self.hass, "comp", {})
          assert not mock_setup.called
  
      @mock.patch("homeassistant.util.package.install_package", return_value=False)
      def test_component_not_installed_if_requirement_fails(self, mock_install):
          """Component setup should fail if requirement can't install."""
          self.hass.config.skip_pip = False
          mock_integration(self.hass, MockModule("comp", requirements=["package==0.0.1"]))
  
          assert not setup.setup_component(self.hass, "comp", {})
          assert "comp" not in self.hass.config.components
  
      def test_component_not_setup_twice_if_loaded_during_other_setup(self):
          """Test component setup while waiting for lock is not set up twice."""
          result = []
  
          @asyncio.coroutine
          def async_setup(hass, config):
              """Tracking Setup."""
              result.append(1)
  
          mock_integration(self.hass, MockModule("comp", async_setup=async_setup))
  
          def setup_component():
              """Set up the component."""
              setup.setup_component(self.hass, "comp", {})
  
          thread = threading.Thread(target=setup_component)
          thread.start()
          setup.setup_component(self.hass, "comp", {})
  
          thread.join()
  
          assert len(result) == 1
  
      def test_component_not_setup_missing_dependencies(self):
          """Test we do not set up a component if not all dependencies loaded."""
          deps = ["maybe_existing"]
          mock_integration(self.hass, MockModule("comp", dependencies=deps))
  
          assert not setup.setup_component(self.hass, "comp", {})
          assert "comp" not in self.hass.config.components
  
          self.hass.data.pop(setup.DATA_SETUP)
  
          mock_integration(self.hass, MockModule("comp2", dependencies=deps))
          mock_integration(self.hass, MockModule("maybe_existing"))
  
          assert setup.setup_component(self.hass, "comp2", {})
  
      def test_component_failing_setup(self):
          """Test component that fails setup."""
          mock_integration(
              self.hass, MockModule("comp", setup=lambda hass, config: False)
          )
  
          assert not setup.setup_component(self.hass, "comp", {})
          assert "comp" not in self.hass.config.components
  
      def test_component_exception_setup(self):
          """Test component that raises exception during setup."""
  
          def exception_setup(hass, config):
              """Raise exception."""
              raise Exception("fail!")
  
          mock_integration(self.hass, MockModule("comp", setup=exception_setup))
  
          assert not setup.setup_component(self.hass, "comp", {})
          assert "comp" not in self.hass.config.components
  
      def test_component_setup_with_validation_and_dependency(self):
          """Test all config is passed to dependencies."""
  
          def config_check_setup(hass, config):
              """Test that config is passed in."""
              if config.get("comp_a", {}).get("valid", False):
                  return True
              raise Exception("Config not passed in: {}".format(config))
  
          platform = MockPlatform()
  
          mock_integration(self.hass, MockModule("comp_a", setup=config_check_setup))
          mock_integration(
              self.hass,
              MockModule("platform_a", setup=config_check_setup, dependencies=["comp_a"]),
          )
  
          mock_entity_platform(self.hass, "switch.platform_a", platform)
  
          setup.setup_component(
              self.hass,
              "switch",
              {"comp_a": {"valid": True}, "switch": {"platform": "platform_a"}},
          )
          assert "comp_a" in self.hass.config.components
  
      def test_platform_specific_config_validation(self):
          """Test platform that specifies config."""
          platform_schema = PLATFORM_SCHEMA.extend(
              {"valid": True}, extra=vol.PREVENT_EXTRA
          )
  
          mock_setup = mock.MagicMock(spec_set=True)
  
          mock_entity_platform(
              self.hass,
              "switch.platform_a",
              MockPlatform(platform_schema=platform_schema, setup_platform=mock_setup),
          )
  
          with assert_setup_component(0, "switch"):
              assert setup.setup_component(
                  self.hass,
                  "switch",
                  {"switch": {"platform": "platform_a", "invalid": True}},
              )
              assert mock_setup.call_count == 0
  
          self.hass.data.pop(setup.DATA_SETUP)
          self.hass.config.components.remove("switch")
  
          with assert_setup_component(0):
              assert setup.setup_component(
                  self.hass,
                  "switch",
                  {
                      "switch": {
                          "platform": "platform_a",
                          "valid": True,
                          "invalid_extra": True,
                      }
                  },
              )
              assert mock_setup.call_count == 0
  
          self.hass.data.pop(setup.DATA_SETUP)
          self.hass.config.components.remove("switch")
  
          with assert_setup_component(1, "switch"):
              assert setup.setup_component(
                  self.hass,
                  "switch",
                  {"switch": {"platform": "platform_a", "valid": True}},
              )
              assert mock_setup.call_count == 1
  
      def test_disable_component_if_invalid_return(self):
          """Test disabling component if invalid return."""
          mock_integration(
              self.hass, MockModule("disabled_component", setup=lambda hass, config: None)
          )
  
          assert not setup.setup_component(self.hass, "disabled_component", {})
          assert "disabled_component" not in self.hass.config.components
  
          self.hass.data.pop(setup.DATA_SETUP)
          mock_integration(
              self.hass,
              MockModule("disabled_component", setup=lambda hass, config: False),
          )
  
          assert not setup.setup_component(self.hass, "disabled_component", {})
          assert "disabled_component" not in self.hass.config.components
  
          self.hass.data.pop(setup.DATA_SETUP)
          mock_integration(
              self.hass, MockModule("disabled_component", setup=lambda hass, config: True)
          )
  
          assert setup.setup_component(self.hass, "disabled_component", {})
          assert "disabled_component" in self.hass.config.components
  
      def test_all_work_done_before_start(self):
          """Test all init work done till start."""
          call_order = []
  
          def component1_setup(hass, config):
              """Set up mock component."""
              discovery.discover(hass, "test_component2", {}, "test_component2", {})
              discovery.discover(hass, "test_component3", {}, "test_component3", {})
              return True
  
          def component_track_setup(hass, config):
              """Set up mock component."""
              call_order.append(1)
              return True
  
          mock_integration(
              self.hass, MockModule("test_component1", setup=component1_setup)
          )
  
          mock_integration(
              self.hass, MockModule("test_component2", setup=component_track_setup)
          )
  
          mock_integration(
              self.hass, MockModule("test_component3", setup=component_track_setup)
          )
  
          @callback
          def track_start(event):
              """Track start event."""
              call_order.append(2)
  
          self.hass.bus.listen_once(EVENT_HOMEASSISTANT_START, track_start)
  
          self.hass.add_job(setup.async_setup_component(self.hass, "test_component1", {}))
          self.hass.block_till_done()
          self.hass.start()
          assert call_order == [1, 1, 2]
  
  
  @asyncio.coroutine
  def test_component_cannot_depend_config(hass):
      """Test config is not allowed to be a dependency."""
      result = yield from setup._async_process_dependencies(
          hass, None, "test", ["config"]
      )
      assert not result
  
  
  @asyncio.coroutine
  def test_component_warn_slow_setup(hass):
      """Warn we log when a component setup takes a long time."""
      mock_integration(hass, MockModule("test_component1"))
      with mock.patch.object(hass.loop, "call_later", mock.MagicMock()) as mock_call:
          result = yield from setup.async_setup_component(hass, "test_component1", {})
          assert result
          assert mock_call.called
          assert len(mock_call.mock_calls) == 3
  
          timeout, logger_method = mock_call.mock_calls[0][1][:2]
  
          assert timeout == setup.SLOW_SETUP_WARNING
          assert logger_method == setup._LOGGER.warning
  
          assert mock_call().cancel.called
  
  
  @asyncio.coroutine
  def test_platform_no_warn_slow(hass):
      """Do not warn for long entity setup time."""
      mock_integration(
          hass, MockModule("test_component1", platform_schema=PLATFORM_SCHEMA)
      )
      with mock.patch.object(hass.loop, "call_later", mock.MagicMock()) as mock_call:
          result = yield from setup.async_setup_component(hass, "test_component1", {})
          assert result
          assert not mock_call.called
  
  
  async def test_when_setup_already_loaded(hass):
      """Test when setup."""
      calls = []
  
      async def mock_callback(hass, component):
          """Mock callback."""
          calls.append(component)
  
      setup.async_when_setup(hass, "test", mock_callback)
      await hass.async_block_till_done()
      assert calls == []
  
      hass.config.components.add("test")
      hass.bus.async_fire(EVENT_COMPONENT_LOADED, {"component": "test"})
      await hass.async_block_till_done()
      assert calls == ["test"]
  
      # Event listener should be gone
      hass.bus.async_fire(EVENT_COMPONENT_LOADED, {"component": "test"})
      await hass.async_block_till_done()
      assert calls == ["test"]
  
      # Should be called right away
      setup.async_when_setup(hass, "test", mock_callback)
      await hass.async_block_till_done()
      assert calls == ["test", "test"]
  