Clean and fix google calendar tests (#23608)

* Clean and fix google calendar tests

* Extract test calendar constant for google test
* Rewrite google calendar tests
* Clean and fix google calendar tests
* Clean and fix google component tests
* Add google conftest
* Skip flaky google calendar test

* Fix google calendar bug

* Fix yield fixture

* Set fixture names to avoid lint warning

* Fix yield fixture

homeassistant/components/google/calendar.py

@@ -72,7 +72,7 @@ class GoogleCalendarData:
             service = self.calendar_service.get()
         except ServerNotFoundError:
             _LOGGER.warning("Unable to connect to Google, using cached data")
-            return False
+            return None, None
         params = dict(DEFAULT_GOOGLE_SEARCH_PARAMS)
         params['calendarId'] = self.calendar_id
         if self.max_results:
@@ -84,12 +84,16 @@ class GoogleCalendarData:
 
     async def async_get_events(self, hass, start_date, end_date):
         """Get all events in a specific time frame."""
-        service, params = await hass.async_add_job(self._prepare_query)
+        service, params = await hass.async_add_executor_job(
+            self._prepare_query)
+        if service is None:
+            return
         params['timeMin'] = start_date.isoformat('T')
         params['timeMax'] = end_date.isoformat('T')
 
-        events = await hass.async_add_job(service.events)
+        events = await hass.async_add_executor_job(service.events)
-        result = await hass.async_add_job(events.list(**params).execute)
+        result = await hass.async_add_executor_job(
+            events.list(**params).execute)
 
         items = result.get('items', [])
         event_list = []
@@ -106,6 +110,8 @@ class GoogleCalendarData:
     def update(self):
         """Get the latest data."""
         service, params = self._prepare_query()
+        if service is None:
+            return False
         params['timeMin'] = dt.now().isoformat('T')
 
         events = service.events()

tests/components/google/conftest.py

@@ -0,0 +1,35 @@
+"""Test configuration and mocks for the google integration."""
+from unittest.mock import patch
+
+import pytest
+
+TEST_CALENDAR = {
+    'id': 'qwertyuiopasdfghjklzxcvbnm@import.calendar.google.com',
+    'etag': '"3584134138943410"',
+    'timeZone': 'UTC',
+    'accessRole': 'reader',
+    'foregroundColor': '#000000',
+    'selected': True,
+    'kind': 'calendar#calendarListEntry',
+    'backgroundColor': '#16a765',
+    'description': 'Test Calendar',
+    'summary': 'We are, we are, a... Test Calendar',
+    'colorId': '8',
+    'defaultReminders': [],
+    'track': True
+}
+
+
+@pytest.fixture
+def test_calendar():
+    """Return a test calendar."""
+    return TEST_CALENDAR
+
+
+@pytest.fixture
+def mock_next_event():
+    """Mock the google calendar data."""
+    patch_google_cal = patch(
+        'homeassistant.components.google.calendar.GoogleCalendarData')
+    with patch_google_cal as google_cal_data:
+        yield google_cal_data

tests/components/google/test_calendar.py

@@ -1,62 +1,37 @@
-"""The tests for the google calendar component."""
+"""The tests for the google calendar platform."""
-# pylint: disable=protected-access
+import copy
-import logging
+from unittest.mock import Mock, patch
-import unittest
-from unittest.mock import patch, Mock
 
+import httplib2
 import pytest
 
-import homeassistant.components.calendar as calendar_base
+from homeassistant.components.google import (
-from homeassistant.components.google import calendar
+    CONF_CAL_ID, CONF_CLIENT_ID, CONF_CLIENT_SECRET, CONF_DEVICE_ID,
-import homeassistant.util.dt as dt_util
+    CONF_ENTITIES, CONF_NAME, CONF_TRACK, DEVICE_SCHEMA,
-from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON
+    SERVICE_SCAN_CALENDARS, do_setup)
+from homeassistant.const import STATE_OFF, STATE_ON
 from homeassistant.helpers.template import DATE_STR_FORMAT
-from tests.common import get_test_home_assistant, MockDependency
+from homeassistant.setup import async_setup_component
+from homeassistant.util import slugify
+import homeassistant.util.dt as dt_util
 
-TEST_PLATFORM = {calendar_base.DOMAIN: {CONF_PLATFORM: 'test'}}
+from tests.common import async_mock_service
 
-_LOGGER = logging.getLogger(__name__)
+GOOGLE_CONFIG = {
+    CONF_CLIENT_ID: 'client_id',
+    CONF_CLIENT_SECRET: 'client_secret',
+}
+TEST_ENTITY = 'calendar.we_are_we_are_a_test_calendar'
+TEST_ENTITY_NAME = 'We are, we are, a... Test Calendar'
 
-
+TEST_EVENT = {
-class TestComponentsGoogleCalendar(unittest.TestCase):
-    """Test the Google calendar."""
-
-    hass = None  # HomeAssistant
-
-    # pylint: disable=invalid-name
-    def setUp(self):
-        """Set up things to be run when tests are started."""
-        self.hass = get_test_home_assistant()
-        self.hass.http = Mock()
-
-        # Set our timezone to CST/Regina so we can check calculations
-        # This keeps UTC-6 all year round
-        dt_util.set_default_time_zone(dt_util.get_time_zone('America/Regina'))
-
-    # pylint: disable=invalid-name
-    def tearDown(self):
-        """Stop everything that was started."""
-        dt_util.set_default_time_zone(dt_util.get_time_zone('UTC'))
-
-        self.hass.stop()
-
-    @patch('homeassistant.components.google.calendar.GoogleCalendarData')
-    def test_all_day_event(self, mock_next_event):
-        """Test that we can create an event trigger on device."""
-        week_from_today = dt_util.dt.date.today() \
-            + dt_util.dt.timedelta(days=7)
-        event = {
     'summary': 'Test All Day Event',
     'start': {
-                'date': week_from_today.isoformat()
     },
     'end': {
-                'date': (week_from_today + dt_util.dt.timedelta(days=1))
-                .isoformat()
     },
     'location': 'Test Cases',
-            'description': 'We\'re just testing that all day events get setup '
+    'description': 'test event',
-                           'correctly',
     'kind': 'calendar#event',
     'created': '2016-06-23T16:37:57.000Z',
     'transparency': 'transparent',
@@ -78,360 +53,265 @@ class TestComponentsGoogleCalendar(unittest.TestCase):
     'htmlLink': 'https://www.google.com/calendar/event?eid=*******',
     'iCalUID': 'cydrevtfuybguinhomj@google.com',
     'status': 'confirmed'
-        }
+}
 
+
+def get_calendar_info(calendar):
+    """Convert data from Google into DEVICE_SCHEMA."""
+    calendar_info = DEVICE_SCHEMA({
+        CONF_CAL_ID: calendar['id'],
+        CONF_ENTITIES: [{
+            CONF_TRACK: calendar['track'],
+            CONF_NAME: calendar['summary'],
+            CONF_DEVICE_ID: slugify(calendar['summary']),
+        }]
+    })
+    return calendar_info
+
+
+@pytest.fixture(autouse=True)
+def mock_google_setup(hass, test_calendar):
+    """Mock the google set up functions."""
+    hass.loop.run_until_complete(
+        async_setup_component(hass, 'group', {'group': {}}))
+    calendar = get_calendar_info(test_calendar)
+    calendars = {calendar[CONF_CAL_ID]: calendar}
+    patch_google_auth = patch(
+        'homeassistant.components.google.do_authentication',
+        side_effect=do_setup)
+    patch_google_load = patch(
+        'homeassistant.components.google.load_config',
+        return_value=calendars)
+    patch_google_services = patch(
+        'homeassistant.components.google.setup_services')
+    async_mock_service(hass, 'google', SERVICE_SCAN_CALENDARS)
+
+    with patch_google_auth, patch_google_load, patch_google_services:
+        yield
+
+
+@pytest.fixture(autouse=True)
+def mock_http(hass):
+    """Mock the http component."""
+    hass.http = Mock()
+
+
+@pytest.fixture(autouse=True)
+def set_time_zone():
+    """Set the time zone for the tests."""
+    # Set our timezone to CST/Regina so we can check calculations
+    # This keeps UTC-6 all year round
+    dt_util.set_default_time_zone(dt_util.get_time_zone('America/Regina'))
+    yield
+    dt_util.set_default_time_zone(dt_util.get_time_zone('UTC'))
+
+
+@pytest.fixture(name='google_service')
+def mock_google_service():
+    """Mock google service."""
+    patch_google_service = patch(
+        'homeassistant.components.google.calendar.GoogleCalendarService')
+    with patch_google_service as mock_service:
+        yield mock_service
+
+
+async def test_all_day_event(hass, mock_next_event):
+    """Test that we can create an event trigger on device."""
+    week_from_today = (
+        dt_util.dt.date.today() + dt_util.dt.timedelta(days=7))
+    end_event = week_from_today + dt_util.dt.timedelta(days=1)
+    event = copy.deepcopy(TEST_EVENT)
+    start = week_from_today.isoformat()
+    end = end_event.isoformat()
+    event['start']['date'] = start
+    event['end']['date'] = end
     mock_next_event.return_value.event = event
 
-        device_name = 'Test All Day'
+    assert await async_setup_component(
+        hass, 'google', {'google': GOOGLE_CONFIG})
+    await hass.async_block_till_done()
 
-        cal = calendar.GoogleCalendarEventDevice(self.hass, None,
+    state = hass.states.get(TEST_ENTITY)
-                                                 '', {'name': device_name})
+    assert state.name == TEST_ENTITY_NAME
-
+    assert state.state == STATE_OFF
-        assert cal.name == device_name
+    assert dict(state.attributes) == {
-
+        'friendly_name': TEST_ENTITY_NAME,
-        assert cal.state == STATE_OFF
-
-        assert not cal.offset_reached()
-
-        assert cal.device_state_attributes == {
         'message': event['summary'],
         'all_day': True,
         'offset_reached': False,
-            'start_time': '{} 00:00:00'.format(event['start']['date']),
+        'start_time': week_from_today.strftime(DATE_STR_FORMAT),
-            'end_time': '{} 00:00:00'.format(event['end']['date']),
+        'end_time': end_event.strftime(DATE_STR_FORMAT),
         'location': event['location'],
         'description': event['description'],
     }
 
-    @patch('homeassistant.components.google.calendar.GoogleCalendarData')
+
-    def test_future_event(self, mock_next_event):
+async def test_future_event(hass, mock_next_event):
     """Test that we can create an event trigger on device."""
-        one_hour_from_now = dt_util.now() \
+    one_hour_from_now = dt_util.now() + dt_util.dt.timedelta(minutes=30)
-            + dt_util.dt.timedelta(minutes=30)
+    end_event = one_hour_from_now + dt_util.dt.timedelta(minutes=60)
-        event = {
+    start = one_hour_from_now.isoformat()
-            'start': {
+    end = end_event.isoformat()
-                'dateTime': one_hour_from_now.isoformat()
+    event = copy.deepcopy(TEST_EVENT)
-            },
+    event['start']['dateTime'] = start
-            'end': {
+    event['end']['dateTime'] = end
-                'dateTime': (one_hour_from_now
-                             + dt_util.dt.timedelta(minutes=60))
-                .isoformat()
-            },
-            'summary': 'Test Event in 30 minutes',
-            'reminders': {'useDefault': True},
-            'id': 'aioehgni435lihje',
-            'status': 'confirmed',
-            'updated': '2016-11-05T15:52:07.329Z',
-            'organizer': {
-                'email': 'uvrttabwegnui4gtia3vyqb@import.calendar.google.com',
-                'displayName': 'Organizer Name',
-                'self': True,
-            },
-            'created': '2016-11-05T15:52:07.000Z',
-            'iCalUID': 'dsfohuygtfvgbhnuju@google.com',
-            'sequence': 0,
-            'creator': {
-                'email': 'uvrttabwegnui4gtia3vyqb@import.calendar.google.com',
-                'displayName': 'Organizer Name',
-            },
-            'etag': '"2956722254658000"',
-            'kind': 'calendar#event',
-            'htmlLink': 'https://www.google.com/calendar/event?eid=*******',
-        }
     mock_next_event.return_value.event = event
 
-        device_name = 'Test Future Event'
+    assert await async_setup_component(
-        device_id = 'test_future_event'
+        hass, 'google', {'google': GOOGLE_CONFIG})
+    await hass.async_block_till_done()
 
-        cal = calendar.GoogleCalendarEventDevice(self.hass, None, device_id,
+    state = hass.states.get(TEST_ENTITY)
-                                                 {'name': device_name})
+    assert state.name == TEST_ENTITY_NAME
-
+    assert state.state == STATE_OFF
-        assert cal.name == device_name
+    assert dict(state.attributes) == {
-
+        'friendly_name': TEST_ENTITY_NAME,
-        assert cal.state == STATE_OFF
-
-        assert not cal.offset_reached()
-
-        assert cal.device_state_attributes == {
         'message': event['summary'],
         'all_day': False,
         'offset_reached': False,
         'start_time': one_hour_from_now.strftime(DATE_STR_FORMAT),
-            'end_time':
+        'end_time': end_event.strftime(DATE_STR_FORMAT),
-                (one_hour_from_now + dt_util.dt.timedelta(minutes=60))
+        'location': event['location'],
-                .strftime(DATE_STR_FORMAT),
+        'description': event['description'],
-            'location': '',
-            'description': '',
     }
 
-    @patch('homeassistant.components.google.calendar.GoogleCalendarData')
+
-    def test_in_progress_event(self, mock_next_event):
+async def test_in_progress_event(hass, mock_next_event):
     """Test that we can create an event trigger on device."""
-        middle_of_event = dt_util.now() \
+    middle_of_event = dt_util.now() - dt_util.dt.timedelta(minutes=30)
-            - dt_util.dt.timedelta(minutes=30)
+    end_event = middle_of_event + dt_util.dt.timedelta(minutes=60)
-        event = {
+    start = middle_of_event.isoformat()
-            'start': {
+    end = end_event.isoformat()
-                'dateTime': middle_of_event.isoformat()
+    event = copy.deepcopy(TEST_EVENT)
-            },
+    event['start']['dateTime'] = start
-            'end': {
+    event['end']['dateTime'] = end
-                'dateTime': (middle_of_event + dt_util.dt
-                             .timedelta(minutes=60))
-                .isoformat()
-            },
-            'summary': 'Test Event in Progress',
-            'reminders': {'useDefault': True},
-            'id': 'aioehgni435lihje',
-            'status': 'confirmed',
-            'updated': '2016-11-05T15:52:07.329Z',
-            'organizer': {
-                'email': 'uvrttabwegnui4gtia3vyqb@import.calendar.google.com',
-                'displayName': 'Organizer Name',
-                'self': True,
-            },
-            'created': '2016-11-05T15:52:07.000Z',
-            'iCalUID': 'dsfohuygtfvgbhnuju@google.com',
-            'sequence': 0,
-            'creator': {
-                'email': 'uvrttabwegnui4gtia3vyqb@import.calendar.google.com',
-                'displayName': 'Organizer Name',
-            },
-            'etag': '"2956722254658000"',
-            'kind': 'calendar#event',
-            'htmlLink': 'https://www.google.com/calendar/event?eid=*******',
-        }
-
     mock_next_event.return_value.event = event
 
-        device_name = 'Test Event in Progress'
+    assert await async_setup_component(
-        device_id = 'test_event_in_progress'
+        hass, 'google', {'google': GOOGLE_CONFIG})
+    await hass.async_block_till_done()
 
-        cal = calendar.GoogleCalendarEventDevice(self.hass, None, device_id,
+    state = hass.states.get(TEST_ENTITY)
-                                                 {'name': device_name})
+    assert state.name == TEST_ENTITY_NAME
-
+    assert state.state == STATE_ON
-        assert cal.name == device_name
+    assert dict(state.attributes) == {
-
+        'friendly_name': TEST_ENTITY_NAME,
-        assert cal.state == STATE_ON
-
-        assert not cal.offset_reached()
-
-        assert cal.device_state_attributes == {
         'message': event['summary'],
         'all_day': False,
         'offset_reached': False,
         'start_time': middle_of_event.strftime(DATE_STR_FORMAT),
-            'end_time':
+        'end_time': end_event.strftime(DATE_STR_FORMAT),
-                (middle_of_event + dt_util.dt.timedelta(minutes=60))
+        'location': event['location'],
-                .strftime(DATE_STR_FORMAT),
+        'description': event['description'],
-            'location': '',
-            'description': '',
     }
 
-    @patch('homeassistant.components.google.calendar.GoogleCalendarData')
+
-    def test_offset_in_progress_event(self, mock_next_event):
+async def test_offset_in_progress_event(hass, mock_next_event):
     """Test that we can create an event trigger on device."""
-        middle_of_event = dt_util.now() \
+    middle_of_event = dt_util.now() + dt_util.dt.timedelta(minutes=14)
-            + dt_util.dt.timedelta(minutes=14)
+    end_event = middle_of_event + dt_util.dt.timedelta(minutes=60)
+    start = middle_of_event.isoformat()
+    end = end_event.isoformat()
     event_summary = 'Test Event in Progress'
-        event = {
+    event = copy.deepcopy(TEST_EVENT)
-            'start': {
+    event['start']['dateTime'] = start
-                'dateTime': middle_of_event.isoformat()
+    event['end']['dateTime'] = end
-            },
+    event['summary'] = '{} !!-15'.format(event_summary)
-            'end': {
-                'dateTime': (middle_of_event + dt_util.dt
-                             .timedelta(minutes=60))
-                .isoformat()
-            },
-            'summary': '{} !!-15'.format(event_summary),
-            'reminders': {'useDefault': True},
-            'id': 'aioehgni435lihje',
-            'status': 'confirmed',
-            'updated': '2016-11-05T15:52:07.329Z',
-            'organizer': {
-                'email': 'uvrttabwegnui4gtia3vyqb@import.calendar.google.com',
-                'displayName': 'Organizer Name',
-                'self': True,
-            },
-            'created': '2016-11-05T15:52:07.000Z',
-            'iCalUID': 'dsfohuygtfvgbhnuju@google.com',
-            'sequence': 0,
-            'creator': {
-                'email': 'uvrttabwegnui4gtia3vyqb@import.calendar.google.com',
-                'displayName': 'Organizer Name',
-            },
-            'etag': '"2956722254658000"',
-            'kind': 'calendar#event',
-            'htmlLink': 'https://www.google.com/calendar/event?eid=*******',
-        }
-
     mock_next_event.return_value.event = event
 
-        device_name = 'Test Event in Progress'
+    assert await async_setup_component(
-        device_id = 'test_event_in_progress'
+        hass, 'google', {'google': GOOGLE_CONFIG})
+    await hass.async_block_till_done()
 
-        cal = calendar.GoogleCalendarEventDevice(self.hass, None, device_id,
+    state = hass.states.get(TEST_ENTITY)
-                                                 {'name': device_name})
+    assert state.name == TEST_ENTITY_NAME
-
+    assert state.state == STATE_OFF
-        assert cal.name == device_name
+    assert dict(state.attributes) == {
-
+        'friendly_name': TEST_ENTITY_NAME,
-        assert cal.state == STATE_OFF
-
-        assert cal.offset_reached()
-
-        assert cal.device_state_attributes == {
         'message': event_summary,
         'all_day': False,
         'offset_reached': True,
         'start_time': middle_of_event.strftime(DATE_STR_FORMAT),
-            'end_time':
+        'end_time': end_event.strftime(DATE_STR_FORMAT),
-                (middle_of_event + dt_util.dt.timedelta(minutes=60))
+        'location': event['location'],
-                .strftime(DATE_STR_FORMAT),
+        'description': event['description'],
-            'location': '',
-            'description': '',
     }
 
-    @pytest.mark.skip
+
-    @patch('homeassistant.components.google.calendar.GoogleCalendarData')
+@pytest.mark.skip
-    def test_all_day_offset_in_progress_event(self, mock_next_event):
+async def test_all_day_offset_in_progress_event(hass, mock_next_event):
     """Test that we can create an event trigger on device."""
-        tomorrow = dt_util.dt.date.today() \
+    tomorrow = dt_util.dt.date.today() + dt_util.dt.timedelta(days=1)
-            + dt_util.dt.timedelta(days=1)
+    end_event = tomorrow + dt_util.dt.timedelta(days=1)
-
+    start = tomorrow.isoformat()
+    end = end_event.isoformat()
     event_summary = 'Test All Day Event Offset In Progress'
-        event = {
+    event = copy.deepcopy(TEST_EVENT)
-            'summary': '{} !!-25:0'.format(event_summary),
+    event['start']['date'] = start
-            'start': {
+    event['end']['date'] = end
-                'date': tomorrow.isoformat()
+    event['summary'] = '{} !!-25:0'.format(event_summary)
-            },
-            'end': {
-                'date': (tomorrow + dt_util.dt.timedelta(days=1))
-                .isoformat()
-            },
-            'location': 'Test Cases',
-            'description': 'We\'re just testing that all day events get setup '
-                           'correctly',
-            'kind': 'calendar#event',
-            'created': '2016-06-23T16:37:57.000Z',
-            'transparency': 'transparent',
-            'updated': '2016-06-24T01:57:21.045Z',
-            'reminders': {'useDefault': True},
-            'organizer': {
-                'email': 'uvrttabwegnui4gtia3vyqb@import.calendar.google.com',
-                'displayName': 'Organizer Name',
-                'self': True
-            },
-            'sequence': 0,
-            'creator': {
-                'email': 'uvrttabwegnui4gtia3vyqb@import.calendar.google.com',
-                'displayName': 'Organizer Name',
-                'self': True
-            },
-            'id': '_c8rinwq863h45qnucyoi43ny8',
-            'etag': '"2933466882090000"',
-            'htmlLink': 'https://www.google.com/calendar/event?eid=*******',
-            'iCalUID': 'cydrevtfuybguinhomj@google.com',
-            'status': 'confirmed'
-        }
-
     mock_next_event.return_value.event = event
 
-        device_name = 'Test All Day Offset In Progress'
+    assert await async_setup_component(
-        device_id = 'test_all_day_offset_in_progress'
+        hass, 'google', {'google': GOOGLE_CONFIG})
+    await hass.async_block_till_done()
 
-        cal = calendar.GoogleCalendarEventDevice(self.hass, None, device_id,
+    state = hass.states.get(TEST_ENTITY)
-                                                 {'name': device_name})
+    assert state.name == TEST_ENTITY_NAME
-
+    assert state.state == STATE_OFF
-        assert cal.name == device_name
+    assert dict(state.attributes) == {
-
+        'friendly_name': TEST_ENTITY_NAME,
-        assert cal.state == STATE_OFF
-
-        assert cal.offset_reached()
-
-        assert cal.device_state_attributes == {
         'message': event_summary,
         'all_day': True,
         'offset_reached': True,
-            'start_time': '{} 06:00:00'.format(event['start']['date']),
+        'start_time': tomorrow.strftime(DATE_STR_FORMAT),
-            'end_time': '{} 06:00:00'.format(event['end']['date']),
+        'end_time': end_event.strftime(DATE_STR_FORMAT),
         'location': event['location'],
         'description': event['description'],
     }
 
-    @patch('homeassistant.components.google.calendar.GoogleCalendarData')
-    def test_all_day_offset_event(self, mock_next_event):
-        """Test that we can create an event trigger on device."""
-        tomorrow = dt_util.dt.date.today() \
-            + dt_util.dt.timedelta(days=2)
 
+async def test_all_day_offset_event(hass, mock_next_event):
+    """Test that we can create an event trigger on device."""
+    tomorrow = dt_util.dt.date.today() + dt_util.dt.timedelta(days=2)
+    end_event = tomorrow + dt_util.dt.timedelta(days=1)
+    start = tomorrow.isoformat()
+    end = end_event.isoformat()
     offset_hours = (1 + dt_util.now().hour)
     event_summary = 'Test All Day Event Offset'
-        event = {
+    event = copy.deepcopy(TEST_EVENT)
-            'summary': '{} !!-{}:0'.format(event_summary, offset_hours),
+    event['start']['date'] = start
-            'start': {
+    event['end']['date'] = end
-                'date': tomorrow.isoformat()
+    event['summary'] = '{} !!-{}:0'.format(event_summary, offset_hours)
-            },
-            'end': {
-                'date': (tomorrow + dt_util.dt.timedelta(days=1))
-                .isoformat()
-            },
-            'location': 'Test Cases',
-            'description': 'We\'re just testing that all day events get setup '
-                           'correctly',
-            'kind': 'calendar#event',
-            'created': '2016-06-23T16:37:57.000Z',
-            'transparency': 'transparent',
-            'updated': '2016-06-24T01:57:21.045Z',
-            'reminders': {'useDefault': True},
-            'organizer': {
-                'email': 'uvrttabwegnui4gtia3vyqb@import.calendar.google.com',
-                'displayName': 'Organizer Name',
-                'self': True
-            },
-            'sequence': 0,
-            'creator': {
-                'email': 'uvrttabwegnui4gtia3vyqb@import.calendar.google.com',
-                'displayName': 'Organizer Name',
-                'self': True
-            },
-            'id': '_c8rinwq863h45qnucyoi43ny8',
-            'etag': '"2933466882090000"',
-            'htmlLink': 'https://www.google.com/calendar/event?eid=*******',
-            'iCalUID': 'cydrevtfuybguinhomj@google.com',
-            'status': 'confirmed'
-        }
-
     mock_next_event.return_value.event = event
 
-        device_name = 'Test All Day Offset'
+    assert await async_setup_component(
-        device_id = 'test_all_day_offset'
+        hass, 'google', {'google': GOOGLE_CONFIG})
+    await hass.async_block_till_done()
 
-        cal = calendar.GoogleCalendarEventDevice(self.hass, None, device_id,
+    state = hass.states.get(TEST_ENTITY)
-                                                 {'name': device_name})
+    assert state.name == TEST_ENTITY_NAME
-
+    assert state.state == STATE_OFF
-        assert cal.name == device_name
+    assert dict(state.attributes) == {
-
+        'friendly_name': TEST_ENTITY_NAME,
-        assert cal.state == STATE_OFF
-
-        assert not cal.offset_reached()
-
-        assert cal.device_state_attributes == {
         'message': event_summary,
         'all_day': True,
         'offset_reached': False,
-            'start_time': '{} 00:00:00'.format(event['start']['date']),
+        'start_time': tomorrow.strftime(DATE_STR_FORMAT),
-            'end_time': '{} 00:00:00'.format(event['end']['date']),
+        'end_time': end_event.strftime(DATE_STR_FORMAT),
         'location': event['location'],
         'description': event['description'],
     }
 
-    @MockDependency("httplib2")
-    def test_update_false(self, mock_httplib2):
-        """Test that the update returns False upon Error."""
-        mock_service = Mock()
-        mock_service.get = Mock(
-            side_effect=mock_httplib2.ServerNotFoundError("unit test"))
 
-        cal = calendar.GoogleCalendarEventDevice(self.hass, mock_service, None,
+async def test_update_false(hass, google_service):
-                                                 {'name': "test"})
+    """Test that the calendar handles a server error."""
-        result = cal.data.update()
+    google_service.return_value.get = Mock(
+        side_effect=httplib2.ServerNotFoundError("unit test"))
+    assert await async_setup_component(
+        hass, 'google', {'google': GOOGLE_CONFIG})
+    await hass.async_block_till_done()
 
-        assert not result
+    state = hass.states.get(TEST_ENTITY)
+    assert state.name == TEST_ENTITY_NAME
+    assert state.state == 'off'

tests/components/google/test_init.py

@@ -1,28 +1,33 @@
 """The tests for the Google Calendar component."""
-import logging
-import unittest
 from unittest.mock import patch
 
+import pytest
+
 import homeassistant.components.google as google
-from homeassistant.setup import setup_component
+from homeassistant.setup import async_setup_component
-from tests.common import get_test_home_assistant
-
-_LOGGER = logging.getLogger(__name__)
 
 
-class TestGoogle(unittest.TestCase):
+@pytest.fixture(name='google_setup')
-    """Test the Google component."""
+def mock_google_setup(hass):
+    """Mock the google set up functions."""
+    p_auth = patch(
+        'homeassistant.components.google.do_authentication',
+        side_effect=google.do_setup)
+    p_service = patch(
+        'homeassistant.components.google.GoogleCalendarService.get')
+    p_discovery = patch(
+        'homeassistant.components.google.discovery.load_platform')
+    p_load = patch(
+        'homeassistant.components.google.load_config',
+        return_value={})
+    p_save = patch(
+        'homeassistant.components.google.update_config')
 
-    def setUp(self):  # pylint: disable=invalid-name
+    with p_auth, p_load, p_service, p_discovery, p_save:
-        """Set up things to be run when tests are started."""
+        yield
-        self.hass = get_test_home_assistant()
 
-    def tearDown(self):  # pylint: disable=invalid-name
-        """Stop everything that was started."""
-        self.hass.stop()
 
-    @patch('homeassistant.components.google.do_authentication')
+async def test_setup_component(hass, google_setup):
-    def test_setup_component(self, mock_do_auth):
     """Test setup component."""
     config = {
         'google': {
@@ -31,27 +36,13 @@ class TestGoogle(unittest.TestCase):
         }
     }
 
-        assert setup_component(self.hass, 'google', config)
+    assert await async_setup_component(hass, 'google', config)
 
-    def test_get_calendar_info(self):
+
+async def test_get_calendar_info(hass, test_calendar):
     """Test getting the calendar info."""
-        calendar = {
+    calendar_info = await hass.async_add_executor_job(
-            'id': 'qwertyuiopasdfghjklzxcvbnm@import.calendar.google.com',
+        google.get_calendar_info, hass, test_calendar)
-            'etag': '"3584134138943410"',
-            'timeZone': 'UTC',
-            'accessRole': 'reader',
-            'foregroundColor': '#000000',
-            'selected': True,
-            'kind': 'calendar#calendarListEntry',
-            'backgroundColor': '#16a765',
-            'description': 'Test Calendar',
-            'summary': 'We are, we are, a... Test Calendar',
-            'colorId': '8',
-            'defaultReminders': [],
-            'track': True
-        }
-
-        calendar_info = google.get_calendar_info(self.hass, calendar)
     assert calendar_info == {
         'cal_id': 'qwertyuiopasdfghjklzxcvbnm@import.calendar.google.com',
         'entities': [{
@@ -62,34 +53,21 @@ class TestGoogle(unittest.TestCase):
         }]
     }
 
-    def test_found_calendar(self):
+
+async def test_found_calendar(
+        hass, google_setup, mock_next_event, test_calendar):
     """Test when a calendar is found."""
-        # calendar = {
+    config = {
-        #     'id': 'qwertyuiopasdfghjklzxcvbnm@import.calendar.google.com',
+        'google': {
-        #     'etag': '"3584134138943410"',
+            'client_id': 'id',
-        #     'timeZone': 'UTC',
+            'client_secret': 'secret',
-        #     'accessRole': 'reader',
+            'track_new_calendar': True,
-        #     'foregroundColor': '#000000',
+        }
-        #     'selected': True,
+    }
-        #     'kind': 'calendar#calendarListEntry',
+    assert await async_setup_component(hass, 'google', config)
-        #     'backgroundColor': '#16a765',
+    assert hass.data[google.DATA_INDEX] == {}
-        #     'description': 'Test Calendar',
-        #     'summary': 'We are, we are, a... Test Calendar',
-        #     'colorId': '8',
-        #     'defaultReminders': [],
-        #     'track': True
-        # }
 
-        # self.assertIsInstance(self.hass.data[google.DATA_INDEX], dict)
+    await hass.services.async_call(
-        # self.assertEqual(self.hass.data[google.DATA_INDEX], {})
+        'google', google.SERVICE_FOUND_CALENDARS, test_calendar, blocking=True)
 
-        calendar_service = google.GoogleCalendarService(
+    assert hass.data[google.DATA_INDEX].get(test_calendar['id']) is not None
-            self.hass.config.path(google.TOKEN_FILE))
-        assert google.setup_services(
-            self.hass, {'google': {}}, True, calendar_service)
-        # self.hass.services.call('google', 'found_calendar', calendar,
-        #                         blocking=True)
-
-        # TODO: Fix this
-        # self.assertTrue(self.hass.data[google.DATA_INDEX]
-        #   # .get(calendar['id'], None) is not None)