Move components to folders (#20774)

* Move all components into folders

* Move component tests into folders

* Fix init moving

* Move tests

* Lint

* Update coverage

* Fix service descriptions

* Update CODEOWNERS

tests/components/plant/test_init.py

@@ -0,0 +1,212 @@
+"""Unit tests for platform/plant.py."""
+import asyncio
+import unittest
+import pytest
+from datetime import datetime, timedelta
+
+from homeassistant.const import (ATTR_UNIT_OF_MEASUREMENT, STATE_UNKNOWN,
+                                 STATE_PROBLEM, STATE_OK)
+from homeassistant.components import recorder
+import homeassistant.components.plant as plant
+from homeassistant.setup import setup_component
+
+from tests.common import get_test_home_assistant, init_recorder_component
+
+
+GOOD_DATA = {
+    'moisture': 50,
+    'battery': 90,
+    'temperature': 23.4,
+    'conductivity': 777,
+    'brightness': 987,
+}
+
+BRIGHTNESS_ENTITY = 'sensor.mqtt_plant_brightness'
+MOISTURE_ENTITY = 'sensor.mqtt_plant_moisture'
+
+GOOD_CONFIG = {
+    'sensors': {
+        'moisture': MOISTURE_ENTITY,
+        'battery': 'sensor.mqtt_plant_battery',
+        'temperature': 'sensor.mqtt_plant_temperature',
+        'conductivity': 'sensor.mqtt_plant_conductivity',
+        'brightness': BRIGHTNESS_ENTITY,
+    },
+    'min_moisture': 20,
+    'max_moisture': 60,
+    'min_battery': 17,
+    'min_conductivity': 500,
+    'min_temperature': 15,
+    'min_brightness': 500,
+}
+
+
+class _MockState:
+
+    def __init__(self, state=None):
+        self.state = state
+
+
+class TestPlant(unittest.TestCase):
+    """Tests for component "plant"."""
+
+    def setUp(self):
+        """Create test instance of home assistant."""
+        self.hass = get_test_home_assistant()
+        self.hass.start()
+
+    def tearDown(self):
+        """Stop everything that was started."""
+        self.hass.stop()
+
+    @asyncio.coroutine
+    def test_valid_data(self):
+        """Test processing valid data."""
+        sensor = plant.Plant('my plant', GOOD_CONFIG)
+        sensor.hass = self.hass
+        for reading, value in GOOD_DATA.items():
+            sensor.state_changed(
+                GOOD_CONFIG['sensors'][reading], None,
+                _MockState(value))
+        assert sensor.state == 'ok'
+        attrib = sensor.state_attributes
+        for reading, value in GOOD_DATA.items():
+            # battery level has a different name in
+            # the JSON format than in hass
+            assert attrib[reading] == value
+
+    @asyncio.coroutine
+    def test_low_battery(self):
+        """Test processing with low battery data and limit set."""
+        sensor = plant.Plant('other plant', GOOD_CONFIG)
+        sensor.hass = self.hass
+        assert sensor.state_attributes['problem'] == 'none'
+        sensor.state_changed('sensor.mqtt_plant_battery',
+                             _MockState(45), _MockState(10))
+        assert sensor.state == 'problem'
+        assert sensor.state_attributes['problem'] == 'battery low'
+
+    def test_initial_states(self):
+        """Test plant initialises attributes if sensor already exists."""
+        self.hass.states.set(MOISTURE_ENTITY, 5,
+                             {ATTR_UNIT_OF_MEASUREMENT: 'us/cm'})
+        plant_name = 'some_plant'
+        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)
+        assert 5 == state.attributes[plant.READING_MOISTURE]
+
+    def test_update_states(self):
+        """Test updating the state of a sensor.
+
+        Make sure that plant processes this correctly.
+        """
+        plant_name = 'some_plant'
+        assert setup_component(self.hass, plant.DOMAIN, {
+            plant.DOMAIN: {
+                plant_name: GOOD_CONFIG
+            }
+        })
+        self.hass.states.set(MOISTURE_ENTITY, 5,
+                             {ATTR_UNIT_OF_MEASUREMENT: 'us/cm'})
+        self.hass.block_till_done()
+        state = self.hass.states.get('plant.'+plant_name)
+        assert STATE_PROBLEM == state.state
+        assert 5 == state.attributes[plant.READING_MOISTURE]
+
+    @pytest.mark.skipif(plant.ENABLE_LOAD_HISTORY is False,
+                        reason="tests for loading from DB are unstable, thus"
+                               "this feature is turned of until tests become"
+                               "stable")
+    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)
+        assert STATE_UNKNOWN == state.state
+        max_brightness = state.attributes.get(
+            plant.ATTR_MAX_BRIGHTNESS_HISTORY)
+        assert 30 == max_brightness
+
+    def test_brightness_history(self):
+        """Test the min_brightness check."""
+        plant_name = 'some_plant'
+        assert setup_component(self.hass, plant.DOMAIN, {
+            plant.DOMAIN: {
+                plant_name: GOOD_CONFIG
+            }
+        })
+        self.hass.states.set(BRIGHTNESS_ENTITY, 100,
+                             {ATTR_UNIT_OF_MEASUREMENT: 'lux'})
+        self.hass.block_till_done()
+        state = self.hass.states.get('plant.'+plant_name)
+        assert STATE_PROBLEM == state.state
+
+        self.hass.states.set(BRIGHTNESS_ENTITY, 600,
+                             {ATTR_UNIT_OF_MEASUREMENT: 'lux'})
+        self.hass.block_till_done()
+        state = self.hass.states.get('plant.'+plant_name)
+        assert STATE_OK == state.state
+
+        self.hass.states.set(BRIGHTNESS_ENTITY, 100,
+                             {ATTR_UNIT_OF_MEASUREMENT: 'lux'})
+        self.hass.block_till_done()
+        state = self.hass.states.get('plant.'+plant_name)
+        assert STATE_OK == state.state
+
+
+class TestDailyHistory(unittest.TestCase):
+    """Test the DailyHistory helper class."""
+
+    def test_no_data(self):
+        """Test with empty history."""
+        dh = plant.DailyHistory(3)
+        assert dh.max is None
+
+    def test_one_day(self):
+        """Test storing data for the same day."""
+        dh = plant.DailyHistory(3)
+        values = [-2, 10, 0, 5, 20]
+        for i in range(len(values)):
+            dh.add_measurement(values[i])
+            max_value = max(values[0:i+1])
+            assert 1 == len(dh._days)
+            assert dh.max == max_value
+
+    def test_multiple_days(self):
+        """Test storing data for different days."""
+        dh = plant.DailyHistory(3)
+        today = datetime.now()
+        today_minus_1 = today - timedelta(days=1)
+        today_minus_2 = today_minus_1 - timedelta(days=1)
+        today_minus_3 = today_minus_2 - timedelta(days=1)
+        days = [today_minus_3, today_minus_2, today_minus_1, today]
+        values = [10, 1, 7, 3]
+        max_values = [10, 10, 10, 7]
+
+        for i in range(len(days)):
+            dh.add_measurement(values[i], days[i])
+            assert max_values[i] == dh.max