def test_load_from_db(self):
        """Test bootstrapping the brightness history from the database.

        This test can should only be executed if the loading of the history
        is enabled via plant.ENABLE_LOAD_HISTORY.
        """
        init_recorder_component(self.hass)
        plant_name = 'wise_plant'
        for value in [20, 30, 10]:

            self.hass.states.set(BRIGHTNESS_ENTITY, value,
                                 {ATTR_UNIT_OF_MEASUREMENT: 'Lux'})
            self.hass.block_till_done()
        # wait for the recorder to really store the data
        self.hass.data[recorder.DATA_INSTANCE].block_till_done()

        assert setup_component(self.hass, plant.DOMAIN, {
            plant.DOMAIN: {
                plant_name: GOOD_CONFIG
            }
        })
        self.hass.block_till_done()

        state = self.hass.states.get('plant.'+plant_name)
        self.assertEqual(STATE_UNKNOWN, state.state)
        max_brightness = state.attributes.get(
            plant.ATTR_MAX_BRIGHTNESS_HISTORY)
        self.assertEqual(30, max_brightness)

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()

    def test_initialize_from_database(self):
        """Test initializing the statistics from the database."""
        # enable the recorder
        init_recorder_component(self.hass)
        # store some values
        for value in self.values:
            self.hass.states.set('sensor.test_monitored', value,
                                 {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS})
            self.hass.block_till_done()
        # wait for the recorder to really store the data
        self.hass.data[recorder.DATA_INSTANCE].block_till_done()
        # only now create the statistics component, so that it must read the
        # data from the database
        assert setup_component(self.hass, 'sensor', {
            'sensor': {
                'platform': 'statistics',
                'name': 'test',
                'entity_id': 'sensor.test_monitored',
                'sampling_size': 100,
            }
        })

        self.hass.start()
        self.hass.block_till_done()

        # check if the result is as in test_sensor_source()
        state = self.hass.states.get('sensor.test_mean')
        assert str(self.mean) == state.state

 def setup_recorder(config=None):
     """Set up with params."""
     init_recorder_component(hass, config)
     hass.start()
     hass.block_till_done()
     hass.data[DATA_INSTANCE].block_till_done()
     return hass

 def setup_recorder(config=None):
     """Setup with params."""
     init_recorder_component(hass, config)
     hass.start()
     hass.block_till_done()
     recorder.get_instance().block_till_done()
     return hass

 def init_recorder(self):
     """Initialize the recorder."""
     init_recorder_component(self.hass)
     self.hass.start()
     recorder.get_instance().block_till_db_ready()
     self.hass.block_till_done()
     recorder.get_instance().block_till_done()

 def setUp(self):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     init_recorder_component(self.hass)  # Force an in memory DB
     mock_http_component(self.hass)
     self.hass.config.components |= set(['frontend', 'recorder', 'api'])
     assert setup_component(self.hass, logbook.DOMAIN,
                            self.EMPTY_CONFIG)
     self.hass.start()

 def setUp(self):  # pylint: disable=invalid-name
     """Setup things to be run when tests are started."""
     config = {'purge_keep_days': 4, 'purge_interval': 2}
     self.hass = get_test_home_assistant()
     init_recorder_component(self.hass, config)
     self.hass.start()

 def init_recorder(self):
     """Initialize the recorder."""
     init_recorder_component(self.hass)
     self.hass.start()
     self.wait_recording_done()

 def setUp(self):
     """Set up things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     init_recorder_component(self.hass)  # Force an in memory DB
     assert setup_component(self.hass, logbook.DOMAIN, self.EMPTY_CONFIG)
     self.hass.start()

 def setUp(self):  # pylint: disable=invalid-name
     """Set up things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     init_recorder_component(self.hass)
     self.hass.start()