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/input_number/test_init.py

@@ -0,0 +1,290 @@
+"""The tests for the Input number component."""
+# pylint: disable=protected-access
+import asyncio
+
+from homeassistant.core import CoreState, State, Context
+from homeassistant.components.input_number import (
+    ATTR_VALUE, DOMAIN, SERVICE_DECREMENT, SERVICE_INCREMENT,
+    SERVICE_SET_VALUE)
+from homeassistant.const import ATTR_ENTITY_ID
+from homeassistant.loader import bind_hass
+from homeassistant.setup import async_setup_component
+
+from tests.common import mock_restore_cache
+
+
+@bind_hass
+def set_value(hass, entity_id, value):
+    """Set input_number to value.
+
+    This is a legacy helper method. Do not use it for new tests.
+    """
+    hass.async_create_task(hass.services.async_call(
+        DOMAIN, SERVICE_SET_VALUE, {
+            ATTR_ENTITY_ID: entity_id,
+            ATTR_VALUE: value,
+        }))
+
+
+@bind_hass
+def increment(hass, entity_id):
+    """Increment value of entity.
+
+    This is a legacy helper method. Do not use it for new tests.
+    """
+    hass.async_create_task(hass.services.async_call(
+        DOMAIN, SERVICE_INCREMENT, {
+            ATTR_ENTITY_ID: entity_id
+        }))
+
+
+@bind_hass
+def decrement(hass, entity_id):
+    """Decrement value of entity.
+
+    This is a legacy helper method. Do not use it for new tests.
+    """
+    hass.async_create_task(hass.services.async_call(
+        DOMAIN, SERVICE_DECREMENT, {
+            ATTR_ENTITY_ID: entity_id
+        }))
+
+
+async def test_config(hass):
+    """Test config."""
+    invalid_configs = [
+        None,
+        {},
+        {'name with space': None},
+        {'test_1': {
+            'min': 50,
+            'max': 50,
+        }},
+    ]
+    for cfg in invalid_configs:
+        assert not await async_setup_component(hass, DOMAIN, {DOMAIN: cfg})
+
+
+async def test_set_value(hass):
+    """Test set_value method."""
+    assert await async_setup_component(hass, DOMAIN, {DOMAIN: {
+        'test_1': {
+            'initial': 50,
+            'min': 0,
+            'max': 100,
+        },
+    }})
+    entity_id = 'input_number.test_1'
+
+    state = hass.states.get(entity_id)
+    assert 50 == float(state.state)
+
+    set_value(hass, entity_id, '30.4')
+    await hass.async_block_till_done()
+
+    state = hass.states.get(entity_id)
+    assert 30.4 == float(state.state)
+
+    set_value(hass, entity_id, '70')
+    await hass.async_block_till_done()
+
+    state = hass.states.get(entity_id)
+    assert 70 == float(state.state)
+
+    set_value(hass, entity_id, '110')
+    await hass.async_block_till_done()
+
+    state = hass.states.get(entity_id)
+    assert 70 == float(state.state)
+
+
+async def test_increment(hass):
+    """Test increment method."""
+    assert await async_setup_component(hass, DOMAIN, {DOMAIN: {
+        'test_2': {
+            'initial': 50,
+            'min': 0,
+            'max': 51,
+        },
+    }})
+    entity_id = 'input_number.test_2'
+
+    state = hass.states.get(entity_id)
+    assert 50 == float(state.state)
+
+    increment(hass, entity_id)
+    await hass.async_block_till_done()
+
+    state = hass.states.get(entity_id)
+    assert 51 == float(state.state)
+
+    increment(hass, entity_id)
+    await hass.async_block_till_done()
+
+    state = hass.states.get(entity_id)
+    assert 51 == float(state.state)
+
+
+async def test_decrement(hass):
+    """Test decrement method."""
+    assert await async_setup_component(hass, DOMAIN, {DOMAIN: {
+        'test_3': {
+            'initial': 50,
+            'min': 49,
+            'max': 100,
+        },
+    }})
+    entity_id = 'input_number.test_3'
+
+    state = hass.states.get(entity_id)
+    assert 50 == float(state.state)
+
+    decrement(hass, entity_id)
+    await hass.async_block_till_done()
+
+    state = hass.states.get(entity_id)
+    assert 49 == float(state.state)
+
+    decrement(hass, entity_id)
+    await hass.async_block_till_done()
+
+    state = hass.states.get(entity_id)
+    assert 49 == float(state.state)
+
+
+async def test_mode(hass):
+    """Test mode settings."""
+    assert await async_setup_component(hass, DOMAIN, {DOMAIN: {
+            'test_default_slider': {
+                'min': 0,
+                'max': 100,
+            },
+            'test_explicit_box': {
+                'min': 0,
+                'max': 100,
+                'mode': 'box',
+            },
+            'test_explicit_slider': {
+                'min': 0,
+                'max': 100,
+                'mode': 'slider',
+            },
+        }})
+
+    state = hass.states.get('input_number.test_default_slider')
+    assert state
+    assert 'slider' == state.attributes['mode']
+
+    state = hass.states.get('input_number.test_explicit_box')
+    assert state
+    assert 'box' == state.attributes['mode']
+
+    state = hass.states.get('input_number.test_explicit_slider')
+    assert state
+    assert 'slider' == state.attributes['mode']
+
+
+@asyncio.coroutine
+def test_restore_state(hass):
+    """Ensure states are restored on startup."""
+    mock_restore_cache(hass, (
+        State('input_number.b1', '70'),
+        State('input_number.b2', '200'),
+    ))
+
+    hass.state = CoreState.starting
+
+    yield from async_setup_component(hass, DOMAIN, {
+        DOMAIN: {
+            'b1': {
+                'min': 0,
+                'max': 100,
+            },
+            'b2': {
+                'min': 10,
+                'max': 100,
+            },
+        }})
+
+    state = hass.states.get('input_number.b1')
+    assert state
+    assert float(state.state) == 70
+
+    state = hass.states.get('input_number.b2')
+    assert state
+    assert float(state.state) == 10
+
+
+@asyncio.coroutine
+def test_initial_state_overrules_restore_state(hass):
+    """Ensure states are restored on startup."""
+    mock_restore_cache(hass, (
+        State('input_number.b1', '70'),
+        State('input_number.b2', '200'),
+    ))
+
+    hass.state = CoreState.starting
+
+    yield from async_setup_component(hass, DOMAIN, {
+        DOMAIN: {
+            'b1': {
+                'initial': 50,
+                'min': 0,
+                'max': 100,
+            },
+            'b2': {
+                'initial': 60,
+                'min': 0,
+                'max': 100,
+            },
+        }})
+
+    state = hass.states.get('input_number.b1')
+    assert state
+    assert float(state.state) == 50
+
+    state = hass.states.get('input_number.b2')
+    assert state
+    assert float(state.state) == 60
+
+
+@asyncio.coroutine
+def test_no_initial_state_and_no_restore_state(hass):
+    """Ensure that entity is create without initial and restore feature."""
+    hass.state = CoreState.starting
+
+    yield from async_setup_component(hass, DOMAIN, {
+        DOMAIN: {
+            'b1': {
+                'min': 0,
+                'max': 100,
+            },
+        }})
+
+    state = hass.states.get('input_number.b1')
+    assert state
+    assert float(state.state) == 0
+
+
+async def test_input_number_context(hass, hass_admin_user):
+    """Test that input_number context works."""
+    assert await async_setup_component(hass, 'input_number', {
+        'input_number': {
+            'b1': {
+                'min': 0,
+                'max': 100,
+            },
+        }
+    })
+
+    state = hass.states.get('input_number.b1')
+    assert state is not None
+
+    await hass.services.async_call('input_number', 'increment', {
+        'entity_id': state.entity_id,
+    }, True, Context(user_id=hass_admin_user.id))
+
+    state2 = hass.states.get('input_number.b1')
+    assert state2 is not None
+    assert state.state != state2.state
+    assert state2.context.user_id == hass_admin_user.id