wbcrm 1.56.8__py2.py3-none-any.whl

wbcrm/synchronization/activity/backends/google/tests/test_google_backend.py

@@ -0,0 +1,319 @@
+# import datetime
+# import json
+# from unittest.mock import patch
+
+# import pytest
+# from django.utils import timezone
+# from dynamic_preferences.registries import global_preferences_registry
+# from rest_framework.test import APIRequestFactory
+# from wbcore.test.utils import get_or_create_superuser
+# from wbcrm.models import ActivityParticipant
+
+# from ..google_calendar_backend import GoogleCalendarBackend
+# from .test_data import credentials, event_data, ExecuteService, ServiceData
+
+
+# class TestInitialisationGoogleCalendarBackend:
+#     @pytest.fixture()
+#     def activity_with_user(self, activity_factory):
+#         user = get_or_create_superuser()
+#         user.metadata = {"google_backend": {"watch": {"id": "fake_id"}}}
+#         user.save()
+#         return activity_factory(creator=user.profile)
+
+#     @pytest.fixture()
+#     def activity_with_user2(self, activity_factory):
+#         user = get_or_create_superuser()
+#         user.metadata = {"google_backend": {"watch": {"id": "fake_id2"}}}
+#         user.save()
+#         return activity_factory(creator=user.profile)
+
+#     @pytest.mark.parametrize("credentials", ["", credentials])
+#     def test_get_service_account_file(self, credentials):
+#         from ..google_calendar_backend import GoogleCalendarBackend
+
+#         global_preferences_registry.manager()["wbactivity_sync__google_sync_credentials"] = credentials
+
+#         backend = GoogleCalendarBackend()
+
+#         if not credentials:
+#             with pytest.raises(ValueError) as excinfo:
+#                 file = backend._get_service_account_file()
+#                 assert (
+#                     "The Google credentials are not set. You cannot use the Google Calendar Backend without the Google credentials."
+#                     in str(excinfo.value)
+#                 )
+#         else:
+#             file = backend._get_service_account_file()
+#             assert file == json.loads(credentials)
+
+#     @pytest.mark.parametrize("credentials", [credentials])
+#     def test_get_service_account_url(self, credentials):
+#         from ..google_calendar_backend import GoogleCalendarBackend
+
+#         global_preferences_registry.manager()["wbactivity_sync__google_sync_credentials"] = credentials
+#         assert GoogleCalendarBackend()._get_service_account_url()
+
+#     def test_get_service_user_email(self, activity_with_user, activity_with_user2, activity_factory):
+#         global_preferences_registry.manager()["wbcrm__main_company"] = employee.employers.first().id
+
+#         activity = activity_factory()
+#         activity1 = activity_factory()
+#         activity2 = activity_with_user2
+#         activity3 = activity_with_user
+#         activity4 = activity_factory(participants=(employee,))
+#         tomorrow = (timezone.now() + datetime.timedelta(days=1)).replace(tzinfo=None)
+#         activity3.creator.user_account.metadata["google_backend"]["watch"]["expiration"] = (
+#             datetime.datetime.timestamp(tomorrow) * 1000
+#         )
+#         activity3.creator.user_account.save()
+#         employee.user_account.metadata = activity3.creator.user_account.metadata
+#         employee.user_account.save()
+#         backend = GoogleCalendarBackend()
+#         assert backend._get_service_user_email(activity) == ""
+#         assert backend._get_service_user_email(activity1) == ""
+#         assert backend._get_service_user_email(activity2) == ""
+#         assert backend._get_service_user_email(activity3) == activity3.creator.user_account.email
+#         assert backend._get_service_user_email(activity4)
+
+#     @patch("wbcrm.synchronization.activity.backends.google.google_calendar_backend.Credentials")
+#     @patch("wbcrm.synchronization.activity.backends.google.google_calendar_backend.build")
+#     @pytest.mark.parametrize("credentials", ["", credentials])
+#     def test_build_service(self, mock_build, mock_credentials, credentials):
+#         global_preferences_registry.manager()["wbactivity_sync__google_sync_credentials"] = credentials
+#         user = get_or_create_superuser()
+#         backend = GoogleCalendarBackend()
+#         if not credentials:
+#             with pytest.raises(ValueError) as excinfo:
+#                 resource = backend._build_service(user.email)
+#                 assert backend.error_messages["service_build_error"] in str(excinfo.value)
+#         else:
+#             resource = backend._build_service(user.email)
+#             assert resource
+
+
+# @patch("wbcrm.synchronization.activity.backends.google.google_calendar_backend.GoogleCalendarBackend._build_service")
+# @patch(
+#     "wbcrm.synchronization.activity.backends.google.google_calendar_backend.GoogleCalendarBackend._get_service_user_email"
+# )
+# @pytest.mark.parametrize(
+#     "sync_past_activity, event", [(False, ""), (True, ""), (False, event_data), (True, event_data)]
+# )
+# @pytest.mark.django_db
+# class TestGoogleCalendarBackend:
+#     @pytest.fixture()
+#     def activity_fixture(self, activity_factory, event):
+#         user = get_or_create_superuser()
+#         user.metadata = {"google_backend": {"watch": {"id": "fake_id"}}}
+#         user.save()
+#         if event:
+#             metadata = {"google_backend": {"event": event}}
+#             return activity_factory(creator=user.profile, metadata=metadata, external_id=event["id"])
+#         else:
+#             metadata = {}
+#             return activity_factory(creator=user.profile, metadata=metadata, external_id=None)
+
+#     def test_create_external_activity(
+#         self, mock_user_email, mock_service, sync_past_activity, event, activity_factory
+#     ):
+#         global_preferences_registry.manager()["wbactivity_sync__sync_past_activity"] = sync_past_activity
+#         now = timezone.now()
+#         yesterday = now - datetime.timedelta(days=1)
+#         tomorrow = now + datetime.timedelta(days=1)
+
+#         activity_passed = activity_factory(start=yesterday, end=yesterday + datetime.timedelta(hours=1))
+#         activity = activity_factory(start=tomorrow, end=tomorrow + datetime.timedelta(hours=1))
+#         activity_with_parent = activity_factory(
+#             start=tomorrow, end=tomorrow + datetime.timedelta(hours=1), parent_occurrence=activity_passed
+#         )
+
+#         mock_service.return_value = service_data()
+#         with patch.object(ExecuteService, "execute", return_value=event):
+
+#             backend = GoogleCalendarBackend()
+#             if event:
+#                 backend.create_external_activity(activity_passed)
+#                 backend.create_external_activity(activity)
+#                 backend.create_external_activity(activity_with_parent)
+#                 assert (
+#                     mock_service.call_count == 2
+#                 )  # 2 instead of 3 because an activity with a parent cannot be synchronized
+
+#             else:
+#                 with pytest.raises(ValueError) as excinfo:
+#                     backend.create_external_activity(activity_passed)
+#                     backend.create_external_activity(activity)
+#                     backend.create_external_activity(activity_with_parent)
+#                     assert "Could not create the external google event. Exception" in str(excinfo.value)
+
+#                     if sync_past_activity:
+#                         assert mock_service.call_count == 1
+#                     else:
+#                         assert mock_service.call_count == 1
+#             activity_passed.refresh_from_db()
+#             activity.refresh_from_db()
+#             activity_with_parent.refresh_from_db()
+
+#             assert activity_with_parent.metadata == {}
+#             assert activity_with_parent.external_id is None
+
+#             if event:
+#                 assert activity.metadata
+#                 assert activity.external_id == event["id"]
+#             else:
+#                 assert activity.metadata == {}
+#                 assert activity.external_id is None
+
+#             if sync_past_activity and event:
+#                 assert activity_passed.metadata
+#                 assert activity_passed.external_id == event["id"]
+#             else:
+#                 assert activity_passed.metadata == {}
+#                 assert activity_passed.external_id is None
+
+#     def test_delete_external_activity(
+#         self, mock_user_email, mock_service, sync_past_activity, event, activity_factory
+#     ):
+#         global_preferences_registry.manager()["wbactivity_sync__sync_past_activity"] = sync_past_activity
+#         now = timezone.now()
+#         yesterday = now - datetime.timedelta(days=1)
+#         tomorrow = now + datetime.timedelta(days=1)
+
+#         activity_passed = activity_factory(start=yesterday, end=yesterday + datetime.timedelta(hours=1))
+#         activity = activity_factory(start=tomorrow, end=tomorrow + datetime.timedelta(hours=1))
+#         activity_with_parent = activity_factory(
+#             start=tomorrow, end=tomorrow + datetime.timedelta(hours=1), parent_occurrence=activity_passed
+#         )
+
+#         mock_service.return_value = service_data()
+#         with patch.object(ExecuteService, "execute", return_value=None):
+
+#             backend = GoogleCalendarBackend()
+#             backend.delete_external_activity(activity_passed)
+#             backend.delete_external_activity(activity)
+#             backend.delete_external_activity(activity_with_parent)
+#             assert mock_service.call_count == 3
+
+#     def test_update_external_activity(
+#         self, mock_user_email, mock_service, sync_past_activity, event, activity_factory
+#     ):
+#         global_preferences_registry.manager()["wbactivity_sync__sync_past_activity"] = sync_past_activity
+#         now = timezone.now()
+#         yesterday = now - datetime.timedelta(days=1)
+#         tomorrow = now + datetime.timedelta(days=1)
+
+#         metadata = {"google_backend": {"instance": event if event else {}}}
+#         external_id = event["id"] if event else None
+#         activity_no_metadata = activity_factory(start=tomorrow, end=tomorrow + datetime.timedelta(hours=1))
+#         activity_passed = activity_factory(
+#             start=yesterday, end=yesterday + datetime.timedelta(hours=1), external_id=external_id, metadata=metadata
+#         )
+#         activity = activity_factory(
+#             start=tomorrow, end=tomorrow + datetime.timedelta(hours=1), external_id=external_id, metadata=metadata
+#         )
+#         activity_with_parent = activity_factory(
+#             start=tomorrow,
+#             end=tomorrow + datetime.timedelta(hours=1),
+#             parent_occurrence=activity_passed,
+#             external_id=external_id,
+#             metadata=metadata,
+#         )
+
+#         mock_service.return_value = service_data()
+#         with patch.object(ExecuteService, "execute", return_value=event if event else {"id": None}):
+#             backend = GoogleCalendarBackend()
+#             backend.update_external_activity(activity_no_metadata)
+#             backend.update_external_activity(activity_passed)
+#             backend.update_external_activity(activity)
+#             backend.update_external_activity(activity_with_parent)
+
+#             assert (
+#                 mock_service.call_count == 5
+#             )  # rather than 4 because we call create_external_activity if no metadata
+#             assert activity_no_metadata.external_id == external_id
+#             assert activity_no_metadata.metadata == {"google_backend": {"event": event if event else {"id": None}}}
+
+#     @pytest.mark.parametrize("response_status", [*list(ActivityParticipant.ParticipationStatus)])
+#     def test_send_participant_response_external_activity(
+#         self,
+#         mock_user_email,
+#         mock_service,
+#         response_status,
+#         sync_past_activity,
+#         event,
+#         person_factory,
+#         activity_fixture,
+#     ):
+#         global_preferences_registry.manager()["wbactivity_sync__sync_past_activity"] = sync_past_activity
+#         activity = activity_fixture
+#         person = person_factory()
+#         activity.participants.add(person, activity.creator)
+#         activity.save()
+#         creator_participant = ActivityParticipant.objects.filter(
+#             activity=activity, participant=activity.creator
+#         ).first()
+#         mock_service.return_value = service_data()
+#         with patch.object(ExecuteService, "execute", return_value=event if event else {"id": None}) as mock_execute:
+#             backend = GoogleCalendarBackend()
+#             activityparticipant = activity.activity_participants.filter(participant=person).first()
+#             backend.send_participant_response_external_activity(activityparticipant, response_status)
+#             backend.send_participant_response_external_activity(creator_participant, response_status)
+#             if event:
+#                 assert mock_execute.call_count
+#             else:
+#                 assert mock_execute.call_count == 0
+
+#     @patch(
+#         "wbcrm.synchronization.activity.backends.google.google_calendar_backend.GoogleCalendarBackend.sync_with_external_calendar"
+#     )
+#     def test_sync_with_external_calendar(
+#         self, mock_handle_changes, mock_user_email, mock_service, sync_past_activity, event
+#     ):
+#         user = get_or_create_superuser()
+#         request = APIRequestFactory().get("", **{"HTTP_X-Goog-Channel-Id": user.id})
+#         backend = GoogleCalendarBackend()
+#         backend.sync_with_external_calendar(request)
+#         assert mock_handle_changes.call_count == 1
+
+#     def test_get_sync_token(self, mock_user_email, mock_service, sync_past_activity, event):
+#         user = get_or_create_superuser()
+#         user.metadata = {"google_backend": {"sync_token": "fake_token"}}
+#         user.save()
+#         backend = GoogleCalendarBackend()
+#         assert backend.get_sync_token(user) == "fake_token"
+
+#     def test_get_external_activity(self, mock_user_email, mock_service, sync_past_activity, event):
+#         pass
+
+#     def test_forward_external_activity(self, mock_user_email, mock_service, sync_past_activity, event):
+#         pass
+
+#     @patch(
+#         "wbcrm.synchronization.activity.backends.google.google_calendar_backend.GoogleCalendarBackend._get_service_account_url"
+#     )
+#     def test_set_web_hook(self, mock_url, mock_user_email, mock_service, sync_past_activity, event):
+#         user = get_or_create_superuser()
+#         watch = {"id": "fake_id"}
+#         mock_service.return_value = service_data()
+#         with patch.object(ExecuteService, "execute", return_value=watch):
+#             GoogleCalendarBackend().set_web_hook(user)
+#         assert user.metadata["google_backend"]["watch"] == watch
+
+#     def test_stop_web_hook(self, mock_user_email, mock_service, sync_past_activity, event):
+#         user = get_or_create_superuser()
+#         user.metadata = {"google_backend": {"watch": {"id": "fake_id", "resourceId": "fake_resource_id"}}}
+#         user.save()
+#         watch = {"id": "fake_id"}
+#         mock_service.return_value = service_data()
+#         with patch.object(ExecuteService, "execute", return_value=watch):
+#             GoogleCalendarBackend().stop_web_hook(user)
+#         assert user.metadata["google_backend"] == {}
+
+#     def test_check_web_hook(self, mock_user_email, mock_service, sync_past_activity, event):
+#         tomorrow = (timezone.now() + datetime.timedelta(days=1)).replace(tzinfo=None)
+#         user = get_or_create_superuser()
+#         user.metadata = {"google_backend": {"watch": {"expiration": datetime.datetime.timestamp(tomorrow) * 1000}}}
+#         user.save()
+#         with pytest.warns() as record:
+#             GoogleCalendarBackend().check_web_hook(user)
+#         assert len(record) == 1

wbcrm/synchronization/activity/backends/google/tests/test_utils.py

@@ -0,0 +1,274 @@
+# import datetime
+# from zoneinfo import ZoneInfo
+
+# import pytest
+# from django.conf import settings
+# from dynamic_preferences.registries import global_preferences_registry
+# from wbcrm.models import (
+#     Activity,
+#     ActivityParticipant,
+#     CalendarItem,
+#     EmailContact,
+#     Person,
+# )
+
+# from ..utils import GoogleSyncUtils
+# from .test_data import event, event_list
+
+
+# @pytest.mark.django_db
+# class TestUtils:
+#     def test_add_instance_metadata(self, activity_factory):
+#         new_metadata = {"google_backend": {"instance": {"uID": "UID"}, "event": {"id": "event id"}}}
+#         parent_occurrence: Activity = activity_factory(
+#             metadata={"google_backend": {"instance": {"originalStartTime": {"dateTime": "Fake Date Time"}}}}
+#         )
+#         child_activity_a: Activity = activity_factory(
+#             parent_occurrence=parent_occurrence,
+#             metadata={"google_backend": {"instance": {"originalStartTime": {"dateTime": "Fake Date Time A"}}}},
+#         )
+#         child_activity_b: Activity = activity_factory(
+#             parent_occurrence=parent_occurrence,
+#             metadata={"google_backend": {"instance": {"originalStartTime": {"dateTime": "Fake Date Time B"}}}},
+#         )
+#         child_activity_c: Activity = activity_factory(
+#             parent_occurrence=parent_occurrence,
+#             metadata={"google_backend": {"instance": {"originalStartTime": {"dateTime": "Fake Date Time C"}}}},
+#         )
+#         GoogleSyncUtils.add_instance_metadata(parent_occurrence, event_list, new_metadata)
+#         parent_occurrence = Activity.objects.get(id=parent_occurrence.id)
+#         child_activity_a = Activity.objects.get(id=child_activity_a.id)
+#         child_activity_b = Activity.objects.get(id=child_activity_b.id)
+#         child_activity_c = Activity.objects.get(id=child_activity_c.id)
+#         assert parent_occurrence.metadata["google_backend"]["instance"]["metaTest"] == "Parent"
+#         assert child_activity_a.external_id == "2"
+#         assert child_activity_a.metadata["google_backend"]["instance"]["metaTest"] == "Child A"
+#         assert child_activity_b.external_id == "3"
+#         assert child_activity_b.metadata["google_backend"]["instance"]["metaTest"] == "Child B"
+#         assert child_activity_c.external_id == "4"
+#         assert child_activity_c.metadata["google_backend"]["instance"]["metaTest"] == "Child C"
+
+#     def test_convert_activity_visibility_to_event_visibility(self):
+#         assert (
+#             GoogleSyncUtils.convert_activity_visibility_to_event_visibility(CalendarItem.Visibility.PUBLIC) == "public"
+#         )
+#         assert (
+#             GoogleSyncUtils.convert_activity_visibility_to_event_visibility(CalendarItem.Visibility.PRIVATE)
+#             == "private"
+#         )
+#         assert (
+#             GoogleSyncUtils.convert_activity_visibility_to_event_visibility(CalendarItem.Visibility.CONFIDENTIAL)
+#             == "private"
+#         )
+
+#     def test_convert_event_visibility_to_activity_visibility(self):
+#         assert (
+#             GoogleSyncUtils.convert_event_visibility_to_activity_visibility("private")
+#             == CalendarItem.Visibility.PRIVATE
+#         ) or (
+#             GoogleSyncUtils.convert_event_visibility_to_activity_visibility("private")
+#             == CalendarItem.Visibility.CONFIDENTIAL
+#         )
+#         assert (
+#             GoogleSyncUtils.convert_event_visibility_to_activity_visibility("public") == CalendarItem.Visibility.PUBLIC
+#         )
+
+#     def test_convert_attendee_status_to_participant_status(self):
+#         assert (
+#             GoogleSyncUtils.convert_attendee_status_to_participant_status("accepted")
+#             == ActivityParticipant.ParticipationStatus.ATTENDS
+#         )
+#         assert (
+#             GoogleSyncUtils.convert_attendee_status_to_participant_status("declined")
+#             == ActivityParticipant.ParticipationStatus.CANCELLED
+#         )
+#         assert (
+#             GoogleSyncUtils.convert_attendee_status_to_participant_status("tentative")
+#             == ActivityParticipant.ParticipationStatus.MAYBE
+#         )
+#         assert (
+#             GoogleSyncUtils.convert_attendee_status_to_participant_status("Something different")
+#             == ActivityParticipant.ParticipationStatus.NOTRESPONDED
+#         )
+
+#     def test_convert_participant_status_to_attendee_status(self):
+#         assert (
+#             GoogleSyncUtils.convert_participant_status_to_attendee_status(
+#                 ActivityParticipant.ParticipationStatus.ATTENDS
+#             )
+#             == "accepted"
+#         )
+#         assert (
+#             GoogleSyncUtils.convert_participant_status_to_attendee_status(
+#                 ActivityParticipant.ParticipationStatus.ATTENDS_DIGITALLY
+#             )
+#             == "accepted"
+#         )
+#         assert (
+#             GoogleSyncUtils.convert_participant_status_to_attendee_status(
+#                 ActivityParticipant.ParticipationStatus.CANCELLED
+#             )
+#             == "declined"
+#         )
+#         assert (
+#             GoogleSyncUtils.convert_participant_status_to_attendee_status(
+#                 ActivityParticipant.ParticipationStatus.MAYBE
+#             )
+#             == "tentative"
+#         )
+#         assert GoogleSyncUtils.convert_participant_status_to_attendee_status("Something different") == "notResponded"
+
+#     @pytest.mark.parametrize("google_event", [{}, event])
+#     def test_get_participants(self, google_event, person_factory, email_contact_factory):
+#         person_a = person_factory()
+#         person_b = person_factory()
+#         person_c = person_factory()
+#         email_contact_factory(primary=True, entry=person_a, address="Foo@Foo.com")
+#         email_contact_factory(primary=True, entry=person_b, address="Bar@Bar.com")
+#         part_list = GoogleSyncUtils.get_or_create_participants(google_event, person_c)
+#         if not google_event:
+#             assert part_list == [{"person_id": person_c.id, "status": ActivityParticipant.ParticipationStatus.ATTENDS}]
+#         else:
+#             person_d = Person.objects.get(last_name="Foo Bar")
+#             person_e = Person.objects.get(last_name="Bar@Foo.com")
+#             assert len(part_list) == 5
+#             assert {"person_id": person_a.id, "status": ActivityParticipant.ParticipationStatus.ATTENDS} in part_list
+#             assert {"person_id": person_b.id, "status": ActivityParticipant.ParticipationStatus.CANCELLED} in part_list
+#             assert {"person_id": person_c.id, "status": ActivityParticipant.ParticipationStatus.ATTENDS} in part_list
+#             assert {"person_id": person_d.id, "status": ActivityParticipant.ParticipationStatus.MAYBE} in part_list
+#             assert {"person_id": person_e.id, "status": ActivityParticipant.ParticipationStatus.MAYBE} in part_list
+
+#     @pytest.mark.parametrize("can_sync", [False, True])
+#     @pytest.mark.parametrize("google_event", [{}, event])
+#     def test_convert_activity_participants_to_attendees_list(
+#         self, can_sync, google_event, activity_factory, person_factory, internal_user_factory, email_contact_factory
+#     ):
+#         global_preferences_registry.manager()["wbactivity_sync__sync_external_participants"] = can_sync
+#         person_a: Person = internal_user_factory()
+#         person_b: Person = person_factory()
+#         person_c: Person = person_factory()
+#         email_contact_factory(primary=True, entry=person_a, address="A@A.com")
+#         email_contact_factory(primary=True, entry=person_b, address="B@B.com")
+#         email_contact_factory(primary=True, entry=person_c, address="Foo@Bar.com")
+#         activity: Activity = activity_factory(creator=person_a, participants=[person_a.id, person_b.id, person_c])
+#         # attendees: list[dict] = convert_activity_participants_to_attendees_list(activity, google_event)
+#         attendees: list[dict] = GoogleSyncUtils.convert_activity_participants_to_attendees(activity, google_event)
+
+#         person_a_dict: dict = {
+#             "displayName": person_a.computed_str,
+#             "email": str(person_a.primary_email_contact()),
+#             "responseStatus": "accepted",
+#         }
+#         person_b_dict: dict = {
+#             "displayName": person_b.computed_str,
+#             "email": str(person_b.primary_email_contact()),
+#             "responseStatus": "needsAction",
+#         }
+#         person_c_dict: dict = {
+#             "displayName": person_c.computed_str,
+#             "email": str(person_c.primary_email_contact()),
+#             "responseStatus": "needsAction",
+#         }
+#         if not google_event and not can_sync:
+#             assert len(attendees) == 1
+#             assert person_a_dict in attendees
+#         elif not google_event and can_sync:
+#             assert len(attendees) == 3
+#             assert person_a_dict in attendees
+#             assert person_b_dict in attendees
+#         elif google_event and not can_sync:
+#             assert len(attendees) == 2
+#             assert person_a_dict in attendees
+#             assert person_c_dict in attendees
+#             assert person_b_dict not in attendees
+#         else:
+#             assert len(attendees) == 3
+#             assert person_a_dict in attendees
+#             assert person_b_dict in attendees
+#             assert person_c_dict in attendees
+
+#     @pytest.mark.parametrize("created", [False])
+#     @pytest.mark.parametrize(
+#         "metadata",
+#         [{}, {"recurrence": ["Recurrence A"], "google_backend": {"event": {"recurrence": ["Recurrence B"]}}}],
+#     )
+#     def test_convert_activity_to_event(
+#         self, internal_user_factory, activity_factory, email_contact_factory, created, metadata
+#     ):
+#         timezone = ZoneInfo(settings.TIME_ZONE)
+#         person_a: Person = internal_user_factory()
+#         person_b: Person = internal_user_factory()
+#         email_contact_factory(primary=True, entry=person_a, address="Foo@Foo.com")
+#         email_contact_factory(primary=True, entry=person_b, address="Bar@Bar.com")
+#         activity: Activity = activity_factory(
+#             creator=person_a,
+#             participants=[person_b.id],
+#             visibility=CalendarItem.Visibility.PUBLIC,
+#             metadata=metadata,
+#         )
+#         event = GoogleSyncUtils.convert_activity_to_event(activity, created)
+#         assert event["summary"] == activity.title
+#         assert event["creator"] == str(activity.creator.primary_email_contact())
+#         assert event["organizer"] == str(activity.assigned_to.primary_email_contact())
+#         assert event["location"] == activity.location
+#         assert event["visibility"] == "public"
+#         assert event["attendees"] == [
+#             {
+#                 "displayName": person_b.computed_str,
+#                 "email": str(person_b.primary_email_contact()),
+#                 "responseStatus": "needsAction",
+#             }
+#         ]
+#         assert event["start"] == {
+#             "dateTime": activity.period.lower.astimezone(timezone).isoformat(),
+#             "timeZone": settings.TIME_ZONE,
+#         }
+#         assert event["end"] == {
+#             "dateTime": activity.period.upper.astimezone(timezone).isoformat(),
+#             "timeZone": settings.TIME_ZONE,
+#         }
+#         if metadata and not created:
+#             assert event["recurrence"] == ["Recurrence B"]
+#         elif metadata and created:
+#             assert event["recurrence"] == ["Recurrence A"]
+#         else:
+#             assert event["recurrence"] == []
+
+#     def test_get_start_and_end(self):
+#         meta = {
+#             "start": {"dateTime": "2022-12-20T11:30:00+01:00", "timeZone": "Europe/Berlin"},
+#             "end": {"dateTime": "2022-12-20T12:30:00+01:00", "timeZone": "Europe/Berlin"},
+#         }
+#         meta_date = {
+#             "start": {"date": "2022-12-24"},
+#             "end": {"date": "2022-12-25"},
+#         }
+#         start, end = GoogleSyncUtils.get_start_and_end(meta)
+#         assert start == datetime.datetime(
+#             2022, 12, 20, 11, 30, tzinfo=datetime.timezone(datetime.timedelta(seconds=3600))
+#         )
+#         assert end == datetime.datetime(
+#             2022, 12, 20, 12, 30, tzinfo=datetime.timezone(datetime.timedelta(seconds=3600))
+#         )
+#         start, end = GoogleSyncUtils.get_start_and_end(meta_date)
+#         assert start == datetime.datetime(2022, 12, 24)
+#         assert end == datetime.datetime(2022, 12, 24, 23, 59, 59)
+
+#     @pytest.mark.parametrize(
+#         "organizer",
+#         ["", "Foo@Foo.com", "Bar@Bar.com"],
+#     )
+#     def test_get_person(self, person_factory, email_contact_factory, organizer):
+#         person_a: Person = person_factory()
+#         email_contact_factory(primary=True, entry=person_a, address="foo@foo.com")
+
+#         if organizer == "Foo@Foo.com":
+#             assert GoogleSyncUtils.get_or_create_person(organizer) == person_a
+#         elif organizer and (mail := organizer) == "Bar@Bar.com":
+#             creator = GoogleSyncUtils.get_or_create_person(mail)
+#             person_b = Person.objects.get(last_name=mail)
+#             assert EmailContact.objects.filter(entry=creator, address=mail.lower(), primary=True).exists()
+#             assert creator.id == person_b.id
+#             assert creator.last_name == mail
+#         else:
+#             assert GoogleSyncUtils.get_or_create_person(organizer) is None