def test_invalid_credentials(
        mock_open, mock_isfile, mock_makedirs, mock_json_dump, mock_json_load,
        mock_create_session, hass):
    """Test with invalid credentials."""
    mock_http_component(hass)

    mock_json_load.return_value = {'refresh_token': 'bad_token'}

    @asyncio.coroutine
    def get_session(*args, **kwargs):
        """Return the test session."""
        raise aioautomatic.exceptions.BadRequestError(
            'err_invalid_refresh_token')

    mock_create_session.side_effect = get_session

    config = {
        'platform': 'automatic',
        'client_id': 'client_id',
        'secret': 'client_secret',
        'devices': None,
    }
    hass.loop.run_until_complete(
        async_setup_scanner(hass, config, None))
    assert mock_create_session.called
    assert len(mock_create_session.mock_calls) == 1
    assert mock_create_session.mock_calls[0][1][0] == 'bad_token'
Exemplo n.º 2
0
 def test_setup(self):
     """ Test setup method. """
     try:
         hass = get_test_home_assistant()
         mock_http_component(hass)
         self.assertTrue(logbook.setup(hass, {}))
     finally:
         hass.stop()
Exemplo n.º 3
0
 def setUp(self):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass)
     self.hass.config.components += ['frontend', 'recorder', 'api']
     with patch('homeassistant.components.logbook.'
                'register_built_in_panel'):
         assert setup_component(self.hass, logbook.DOMAIN,
                                self.EMPTY_CONFIG)
Exemplo n.º 4
0
def test_setup_check_env_prevents_load(hass, loop):
    """Test it does not set up hassbian if environment var not present."""
    mock_http_component(hass)
    with patch.dict(os.environ, clear=True), \
            patch.object(config, 'SECTIONS', ['hassbian']):
        loop.run_until_complete(async_setup_component(hass, 'config', {}))
    assert 'config' in hass.config.components
    assert HassbianSuitesView.name not in hass.http.views
    assert HassbianSuiteInstallView.name not in hass.http.views
Exemplo n.º 5
0
 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()
Exemplo n.º 6
0
def test_setup_check_env_works(hass, loop):
    """Test it sets up hassbian if environment var present."""
    mock_http_component(hass)
    with patch.dict(os.environ, {'FORCE_HASSBIAN': '1'}), \
            patch.object(config, 'SECTIONS', ['hassbian']):
        loop.run_until_complete(async_setup_component(hass, 'config', {}))
    assert 'config' in hass.config.components
    assert HassbianSuitesView.name in hass.http.views
    assert HassbianSuiteInstallView.name in hass.http.views
Exemplo n.º 7
0
def test_frontend_panel_register(hass, mock_openzwave):
    """Test network auto-heal disabled."""
    mock_http_component(hass)
    hass.config.components |= set(['frontend'])
    with patch('homeassistant.components.zwave.'
               'register_built_in_panel') as mock_register:
        assert (yield from async_setup_component(hass, 'zwave', {
            'zwave': {
                'autoheal': False,
            }}))
    assert mock_register.called
    assert len(mock_register.mock_calls) == 1
Exemplo n.º 8
0
 def test_setup(self):
     """Test setup method of history."""
     mock_http_component(self.hass)
     config = history.CONFIG_SCHEMA({
         ha.DOMAIN: {},
         history.DOMAIN: {history.CONF_INCLUDE: {
                 history.CONF_DOMAINS: ['media_player'],
                 history.CONF_ENTITIES: ['thermostat.test']},
             history.CONF_EXCLUDE: {
                 history.CONF_DOMAINS: ['thermostat'],
                 history.CONF_ENTITIES: ['media_player.test']}}})
     self.assertTrue(setup_component(self.hass, history.DOMAIN, config))
Exemplo n.º 9
0
def test_file_not_readable(hass):
    """Test local file will not setup when file is not readable."""
    mock_http_component(hass)

    def run_test():
        with mock.patch('os.path.isfile', mock.Mock(return_value=True)), \
                mock.patch('os.access', return_value=False), \
                assert_setup_component(0, 'camera'):
            assert setup_component(hass, 'camera', {
                'camera': {
                    'name': 'config_test',
                    'platform': 'local_file',
                    'file_path': 'mock.file',
                }})

    yield from hass.loop.run_in_executor(None, run_test)
Exemplo n.º 10
0
def test_file_not_readable(hass, caplog):
    """Test a warning is shown setup when file is not readable."""
    mock_http_component(hass)

    @mock.patch('os.path.isfile', mock.Mock(return_value=True))
    @mock.patch('os.access', mock.Mock(return_value=False))
    def run_test():

        caplog.set_level(
            logging.WARNING, logger='requests.packages.urllib3.connectionpool')

        assert setup_component(hass, 'camera', {
            'camera': {
                'name': 'config_test',
                'platform': 'local_file',
                'file_path': 'mock.file',
            }})
        assert 'Could not read' in caplog.text
        assert 'config_test' in caplog.text
        assert 'mock.file' in caplog.text

    yield from hass.loop.run_in_executor(None, run_test)
Exemplo n.º 11
0
 def setUp(self):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass)
Exemplo n.º 12
0
 def setUp(self):  # pylint: disable=invalid-name
     self.hass = ha.HomeAssistant()
     mock_http_component(self.hass)
Exemplo n.º 13
0
 def setUp(self):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass)
     self.assertTrue(logbook.setup(self.hass, {}))
Exemplo n.º 14
0
 def setUp(self):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass)
     self.assertTrue(logbook.setup(self.hass, {}))
Exemplo n.º 15
0
def stub_http(hass):
    """Stub the HTTP component."""
    mock_http_component(hass)
Exemplo n.º 16
0
 def setUp(self):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass)
     assert setup_component(self.hass, logbook.DOMAIN, self.EMPTY_CONFIG)
 def setup_method(self, method):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass, 'super_secret')
Exemplo n.º 18
0
 def setUp(self):
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass)
     assert setup_component(self.hass, logbook.DOMAIN, self.EMPTY_CONFIG)
Exemplo n.º 19
0
 def setUp(self):
     """ Test setup method. """
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass)
     self.assertTrue(logbook.setup(self.hass, {}))
Exemplo n.º 20
0
def test_valid_credentials(
        mock_open, mock_isfile, mock_makedirs, mock_json_dump, mock_json_load,
        mock_ws_connect, mock_create_session, hass):
    """Test with valid credentials."""
    mock_http_component(hass)

    mock_json_load.return_value = {'refresh_token': 'good_token'}

    session = MagicMock()
    vehicle = MagicMock()
    trip = MagicMock()
    mock_see = MagicMock()

    vehicle.id = 'mock_id'
    vehicle.display_name = 'mock_display_name'
    vehicle.fuel_level_percent = 45.6
    vehicle.latest_location = None
    vehicle.updated_at = datetime(2017, 8, 13, 1, 2, 3)

    trip.end_location.lat = 45.567
    trip.end_location.lon = 34.345
    trip.end_location.accuracy_m = 5.6
    trip.ended_at = datetime(2017, 8, 13, 1, 2, 4)

    @asyncio.coroutine
    def get_session(*args, **kwargs):
        """Return the test session."""
        return session

    @asyncio.coroutine
    def get_vehicles(*args, **kwargs):
        """Return list of test vehicles."""
        return [vehicle]

    @asyncio.coroutine
    def get_trips(*args, **kwargs):
        """Return list of test trips."""
        return [trip]

    mock_create_session.side_effect = get_session
    session.ws_connect = MagicMock()
    session.get_vehicles.side_effect = get_vehicles
    session.get_trips.side_effect = get_trips
    session.refresh_token = 'mock_refresh_token'

    @asyncio.coroutine
    def ws_connect():
        return asyncio.Future(loop=hass.loop)

    mock_ws_connect.side_effect = ws_connect

    config = {
        'platform': 'automatic',
        'username': '******',
        'password': '******',
        'client_id': 'client_id',
        'secret': 'client_secret',
        'devices': None,
    }
    result = hass.loop.run_until_complete(
        async_setup_scanner(hass, config, mock_see))

    hass.async_block_till_done()

    assert result

    assert mock_create_session.called
    assert len(mock_create_session.mock_calls) == 1
    assert mock_create_session.mock_calls[0][1][0] == 'good_token'

    assert mock_see.called
    assert len(mock_see.mock_calls) == 2
    assert mock_see.mock_calls[0][2]['dev_id'] == 'mock_id'
    assert mock_see.mock_calls[0][2]['mac'] == 'mock_id'
    assert mock_see.mock_calls[0][2]['host_name'] == 'mock_display_name'
    assert mock_see.mock_calls[0][2]['attributes'] == {'fuel_level': 45.6}
    assert mock_see.mock_calls[0][2]['gps'] == (45.567, 34.345)
    assert mock_see.mock_calls[0][2]['gps_accuracy'] == 5.6

    assert mock_json_dump.called
    assert len(mock_json_dump.mock_calls) == 1
    assert mock_json_dump.mock_calls[0][1][0] == {
        'refresh_token': 'mock_refresh_token'
    }
Exemplo n.º 21
0
 def setUp(self):  # pylint: disable=invalid-name
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass)
Exemplo n.º 22
0
 def test_setup(self):
     """ Test setup method of history. """
     mock_http_component(self.hass)
     self.assertTrue(history.setup(self.hass, {}))
Exemplo n.º 23
0
 def setUp(self):  # pylint: disable=invalid-name
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass)
Exemplo n.º 24
0
 def setUp(self):  # pylint: disable=invalid-name
     self.hass = ha.HomeAssistant()
     mock_http_component(self.hass)
Exemplo n.º 25
0
 def setUp(self):
     """ Test setup method. """
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass)
     self.assertTrue(logbook.setup(self.hass, {}))
Exemplo n.º 26
0
 def test_setup(self):
     """ Test setup method of history. """
     mock_http_component(self.hass)
     self.assertTrue(history.setup(self.hass, {}))
Exemplo n.º 27
0
def stub_http(hass):
    """Stub the HTTP component."""
    mock_http_component(hass)
Exemplo n.º 28
0
 def setUp(self):  # pylint: disable=invalid-name
     """Setup things to be run when tests are started."""
     self.hass = get_test_home_assistant()
     mock_http_component(self.hass)