wbcrm 2.2.1__py2.py3-none-any.whl

wbcrm/synchronization/activity/backends/outlook/tests/test_admin.py

@@ -0,0 +1,117 @@
+from unittest.mock import patch
+
+import pytest
+from django.contrib.admin import AdminSite
+from django.contrib.auth import get_user_model
+from django.contrib.messages import get_messages
+from dynamic_preferences.registries import global_preferences_registry
+from rest_framework import status
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcrm.synchronization.activity.admin import UserSyncAdmin
+
+from .fixtures import TestOutlookSyncFixture, msgraph_fixture
+
+
+@pytest.mark.parametrize(
+    "backend, credentials, subscription, tenant_id",
+    [
+        (False, True, {"id": "fake_id"}, "fake_tenant_id"),
+        (True, False, None, None),
+        (True, True, None, None),
+        (True, True, {"id": "fake_id"}, None),
+        (True, True, {"id": "fake_id"}, "fake_tenant_id"),
+    ],
+)
+@patch("wbcrm.synchronization.activity.backends.outlook.backend.MicrosoftGraphAPI")
+@pytest.mark.django_db
+class TestAdminUserWebhook(TestOutlookSyncFixture):
+    def _initialiation(self, mock_msgraph, backend, credentials, subscription, tenant_id, credentials_fixture):
+        preferences = global_preferences_registry.manager()
+        preferences["wbactivity_sync__sync_backend_calendar"] = preferences[
+            "wbactivity_sync__outlook_sync_credentials"
+        ] = ""
+        if backend:
+            preferences[
+                "wbactivity_sync__sync_backend_calendar"
+            ] = "wbcrm.synchronization.activity.backends.outlook.backend.OutlookSyncBackend"
+        mock_msgraph.return_value.status_code = status.HTTP_200_OK
+        mock_msgraph.return_value = msgraph_fixture()
+        if credentials:
+            preferences["wbactivity_sync__outlook_sync_credentials"] = credentials_fixture
+            msgraph_fixture._subscription = subscription
+            msgraph_fixture.tenant_id = tenant_id
+        else:
+            mock_msgraph.side_effect = AssertionError("Invalid URL")
+        user = UserFactory(is_superuser=True)
+        if subscription:
+            user.metadata = {"outlook": {"subscription": subscription}}
+            user.save()
+        return user
+
+    def test_set_web_hook(
+        self, mock_msgraph, backend, credentials, subscription, tenant_id, fixture_request, credentials_fixture
+    ):
+        user = self._initialiation(mock_msgraph, backend, credentials, subscription, tenant_id, credentials_fixture)
+        fixture_request.user = user
+        assert len([m.message for m in get_messages(fixture_request)]) == 0
+        user_admin = UserSyncAdmin(UserFactory, AdminSite())
+        user_admin.set_web_hook(fixture_request, get_user_model().objects.filter(id=user.id))
+        messages = [m.message for m in get_messages(fixture_request)]
+        assert len(messages) == 1
+        if backend:
+            if credentials:
+                if subscription or tenant_id:
+                    assert "Operation completed" in messages[0]
+                else:
+                    assert messages[0] == f"Operation Failed, Outlook TenantId not found for: {user}"
+            else:
+                assert "Operation Failed, Invalid URL" in messages[0]
+        else:
+            assert messages[0] == "Operation Failed, No backend set in preferences"
+
+    def test_stop_web_hook(
+        self, mock_msgraph, backend, credentials, subscription, tenant_id, fixture_request, credentials_fixture
+    ):
+        user = self._initialiation(mock_msgraph, backend, credentials, subscription, tenant_id, credentials_fixture)
+        fixture_request.user = user
+        assert len([m.message for m in get_messages(fixture_request)]) == 0
+        user_admin = UserSyncAdmin(UserFactory, AdminSite())
+        user_admin.stop_web_hook(fixture_request, get_user_model().objects.filter(id=user.id))
+        messages = [m.message for m in get_messages(fixture_request)]
+        assert len(messages) == 1
+        if backend:
+            if subscription:
+                if credentials:
+                    assert "Operation completed" in messages[0]
+                else:
+                    assert "Operation Failed, Invalid URL" in messages[0]
+            else:
+                assert f"Operation Failed, {user} has no active webhook"
+        else:
+            assert messages[0] == "Operation Failed, No backend set in preferences"
+
+    def test_check_web_hook(
+        self, mock_msgraph, backend, credentials, subscription, tenant_id, fixture_request, credentials_fixture
+    ):
+        user = self._initialiation(mock_msgraph, backend, credentials, subscription, tenant_id, credentials_fixture)
+        fixture_request.user = user
+        assert len([m.message for m in get_messages(fixture_request)]) == 0
+        user_admin = UserSyncAdmin(UserFactory, AdminSite())
+        user_admin.check_web_hook(fixture_request, get_user_model().objects.filter(id=user.id))
+        messages = [m.message for m in get_messages(fixture_request)]
+        assert len(messages) == 1
+        if backend:
+            if credentials:
+                if subscription:
+                    assert "Operation completed" in messages[0]
+                elif tenant_id:
+                    assert (
+                        "Operation Failed, Webhook not found. Number of subscriptions found in outlook for"
+                        in messages[0]
+                    )
+                else:
+                    assert messages[0] == f"Operation Failed, Webhook not found. TenantId not found for {user}"
+            else:
+                assert "Operation Failed, Invalid URL" in messages[0]
+        else:
+            assert messages[0] == "Operation Failed, No backend set in preferences"

wbcrm/synchronization/activity/backends/outlook/tests/test_backend.py

@@ -0,0 +1,269 @@
+import json
+from unittest.mock import patch
+
+import pytest
+from dynamic_preferences.registries import global_preferences_registry
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcrm.models.activities import Activity
+from wbcrm.synchronization.activity.backends.outlook.backend import OutlookSyncBackend
+
+from .fixtures import TestOutlookSyncFixture, msgraph_fixture
+
+
+@pytest.mark.django_db
+class TestOutlookSyncBackend(TestOutlookSyncFixture):
+    backend = OutlookSyncBackend()
+
+    def test_attribute(self):
+        assert OutlookSyncBackend.METADATA_KEY == "outlook"
+
+    def test_open(self):
+        preferences = global_preferences_registry.manager()
+        preferences["wbactivity_sync__outlook_sync_credentials"] = ""
+        assert hasattr(self.backend, "msgraph") is False
+        self.backend.open()
+        assert self.backend.msgraph
+
+    @pytest.mark.parametrize("type_request", [None, "validationToken", "admin_consent"])
+    def test_validation_response(self, type_request):
+        request1 = APIRequestFactory().get("")
+        if type_request:
+            request1.GET = request1.GET.copy()
+            request1.GET[type_request] = "fake_info"
+            assert self.backend._validation_response(request1).content.decode("UTF-8") == "fake_info"
+        else:
+            assert self.backend._validation_response(request1) is None
+
+    @pytest.mark.parametrize("client_state", [False, True])
+    def test_is_inbound_request_valid(
+        self, client_state, notification_created_fixture, notification_call_record_fixture
+    ):
+        api_factory = APIRequestFactory()
+        request1 = api_factory.post("", data={})
+        request2 = api_factory.post(
+            "", data=json.dumps({"value": [notification_call_record_fixture]}), content_type="application/json"
+        )
+        request3 = api_factory.post(
+            "", data=json.dumps({"value": [notification_created_fixture]}), content_type="application/json"
+        )
+        preferences = global_preferences_registry.manager()
+        preferences["wbactivity_sync__outlook_sync_client_state"] = ""
+        if client_state:
+            preferences["wbactivity_sync__outlook_sync_client_state"] = notification_created_fixture["client_state"]
+
+        assert self.backend._is_inbound_request_valid(request1) is False
+        assert self.backend._is_inbound_request_valid(request2) is False
+        assert self.backend._is_inbound_request_valid(request3) == client_state
+
+    @pytest.mark.parametrize("event_found, is_organizer", [(False, True), (True, True), (True, False)])
+    @patch("wbcrm.synchronization.activity.backends.outlook.backend.MicrosoftGraphAPI")
+    def test_get_events_from_request(
+        self,
+        mock_msgraph,
+        event_found,
+        is_organizer,
+        notification_created_fixture,
+        organizer_event_fixture_parsed,
+        invitation_event_fixture_parsed,
+    ):
+        api_factory = APIRequestFactory()
+        request1 = api_factory.post(
+            "", data=json.dumps({"value": [notification_created_fixture]}), content_type="application/json"
+        )
+        self.backend.open()
+        self.backend.msgraph = msgraph_fixture()
+        if event_found:
+            if is_organizer:
+                msgraph_fixture.event = organizer_event_fixture_parsed
+                msgraph_fixture.tenant_id = "fake_tenant_id"
+            else:
+                msgraph_fixture.event = invitation_event_fixture_parsed
+                msgraph_fixture.event_by_uid = organizer_event_fixture_parsed
+        events = self.backend._get_events_from_request(request1)
+        assert len(events) == 1
+        if event_found:
+            assert {"change_type", "resource", "subscription_id"}.issubset(set(events[0].keys()))
+            assert events[0].get("id")
+        else:
+            assert {"change_type", "resource", "subscription_id"} == set(events[0].keys())
+
+    def test_deserialize(self, organizer_event_fixture_parsed, organizer_master_event_fixture_parsed):
+        activity_dto0, is_deleted0, user_dto0 = self.backend._deserialize(
+            organizer_event_fixture_parsed, include_metadata=False
+        )
+        activity_dto, is_deleted, user_dto = self.backend._deserialize(organizer_event_fixture_parsed)
+        activity_dto2, is_deleted2, user_dto2 = self.backend._deserialize(organizer_master_event_fixture_parsed)
+
+        assert is_deleted0 == is_deleted == is_deleted2 is False
+        assert user_dto0 == user_dto == user_dto2 is None
+        assert activity_dto0.metadata == {}
+        assert activity_dto.metadata == {
+            self.backend.METADATA_KEY: {
+                "event_uid": organizer_event_fixture_parsed["uid"],
+                "event_id": organizer_event_fixture_parsed["id"],
+            }
+        }
+        assert activity_dto2.metadata == {
+            self.backend.METADATA_KEY: {
+                "event_uid": organizer_master_event_fixture_parsed["uid"],
+                "event_id": organizer_master_event_fixture_parsed["id"],
+            }
+        }
+        assert activity_dto.period
+        assert activity_dto.repeat_choice == "NEVER"
+        assert activity_dto2.repeat_choice != "NEVER"
+
+    def test_serialize(self, activity_factory):
+        activity_dto = activity_factory(preceded_by=None)._build_dto()
+        act_dto = activity_factory(
+            repeat_choice=Activity.ReoccuranceChoice.DAILY, recurrence_count=3, preceded_by=None
+        )._build_dto()
+        activity_dict = self.backend._serialize(activity_dto)
+        activity_dict1 = self.backend._serialize(activity_dto, created=True)
+        act_dict = self.backend._serialize(act_dto)
+        act_dict1 = self.backend._serialize(act_dto, created=True)
+        keys = {
+            "subject",
+            "start",
+            "end",
+            "body",
+            "attendees",
+            "sensitivity",
+            "isReminderOn",
+            "reminderMinutesBeforeStart",
+            "isAllDay",
+            "responseRequested",
+            "location",
+            "locations",
+        }
+        assert set(activity_dict.keys()) == set(act_dict.keys()) == set(activity_dict1.keys()) == keys
+        assert set(act_dict1.keys()) == keys.union({"recurrence"})
+
+    @pytest.mark.parametrize(
+        "metadata, master_event",
+        [
+            ({}, False),
+            ({}, True),
+            ({"organizer_resource": "fake_resource"}, False),
+            ({"organizer_resource": "fake_resource"}, True),
+            ({"event_id": "fake_event_id"}, False),
+            ({"event_id": "fake_event_id"}, True),
+            ({"event_uid": "fake_event_uid"}, False),
+            ({"event_uid": "fake_event_uid"}, True),
+            ({"occurrence_resource": "fake_resource"}, False),
+            ({"occurrence_resource": "fake_resource"}, True),
+            ({"occurrence_id": "fake_occurrence_id"}, False),
+            ({"occurrence_id": "fake_occurrence_id"}, True),
+        ],
+    )
+    def test_get_external_event(self, metadata, master_event, activity_factory):
+        activity_dto = activity_factory(preceded_by=None)._build_dto()
+        activity_dto2 = activity_factory(preceded_by=None, metadata={self.backend.METADATA_KEY: metadata})._build_dto()
+        self.backend.open()
+        self.backend.msgraph = msgraph_fixture()
+        msgraph_fixture.tenant_id = "fake_tenant_id"
+        msgraph_fixture.event_by_uid = msgraph_fixture.event = {"id": "event_id"}
+        assert (
+            self.backend.get_external_event(activity_dto, master_event)
+            == self.backend.get_external_event(activity_dto, master_event)
+            is None
+        )
+        if metadata:
+            event_result = self.backend.get_external_event(activity_dto2, master_event)
+            if master_event or not activity_dto2.is_recurrent:
+                if metadata.get("event_uid") or metadata.get("event_id") or metadata.get("organizer_resource"):
+                    assert event_result == {"id": "event_id"}
+                else:
+                    assert event_result is None
+            else:
+                if metadata.get("occurrence_resource") or metadata.get("occurrence_id"):
+                    assert event_result == {"id": "event_id"}
+                else:
+                    assert event_result is None
+        else:
+            assert self.backend.get_external_event(activity_dto2, master_event) is None
+
+    def test_get_external_participants(self, activity_factory, person_factory):
+        person = person_factory()
+        activity_dto = activity_factory(preceded_by=None, participants=(person,))._build_dto()
+        activity_dto2 = activity_factory(
+            preceded_by=None,
+            participants=(person,),
+            metadata={self.backend.METADATA_KEY: {"organizer_resource": "fake_resource"}},
+        )._build_dto()
+        self.backend.open()
+        self.backend.msgraph = msgraph_fixture()
+        msgraph_fixture.tenant_id = "fake_tenant_id"
+        msgraph_fixture.event_by_uid = msgraph_fixture.event = {
+            "id": "event_id",
+            "attendees": [{"emailAddress": {"address": person._build_dto().email}}],
+        }
+        assert len(self.backend.get_external_participants(activity_dto, [])) == 0
+        assert len(self.backend.get_external_participants(activity_dto2, [])) == 1
+        assert len(self.backend.get_external_participants(activity_dto2, activity_dto2.participants)) == 0
+
+    @patch("wbcrm.synchronization.activity.backends.outlook.backend.MicrosoftGraphAPI")
+    def test_is_participant_valid(self, mock_msgraph):
+        user = UserFactory(is_superuser=True)
+        user2 = UserFactory(is_superuser=True)
+        user2.metadata = {self.backend.METADATA_KEY: {"subscription": {"id": "fake_subscription_id"}}}
+        user2.save()
+        msgraph_fixture._subscription = {"id": "fake_subscription_id"}
+        mock_msgraph.return_value = msgraph_fixture()
+        assert self.backend._is_participant_valid(user2) is True
+        assert self.backend._is_participant_valid(user) is False
+
+    def test_generate_event_metadata(self):
+        event = {"id": "fake_id", "uid": "fake_uid"}
+        occurrence_event = {"id": "fake_id", "uid": "fake_uid"}
+        resource = f"Users/fake_tenant_id/Events/{event['id']}"
+        result = {
+            "resources": [resource],
+            "organizer_resource": resource,
+            "event_uid": event["uid"],
+            "event_id": event["id"],
+        }
+        metadata = self.backend._generate_event_metadata("fake_tenant_id", event)
+        metadata2 = self.backend._generate_event_metadata("fake_tenant_id", event, occurrence_event)
+        assert metadata == {self.backend.METADATA_KEY: result}
+        assert metadata2 == {
+            self.backend.METADATA_KEY: {**result, **{"occurrence_id": event["id"], "occurrence_resource": resource}}
+        }
+
+    def test_get_metadata_from_event(
+        self, activity_factory, organizer_event_fixture_parsed, organizer_master_event_fixture_parsed
+    ):
+        self.backend.open()
+        self.backend.msgraph = msgraph_fixture()
+        msgraph_fixture.tenant_id = "fake_tenant_id"
+        activity_dto = activity_factory(preceded_by=None)._build_dto()
+        metadata_list = self.backend._get_metadata_from_event(activity_dto, organizer_event_fixture_parsed)
+        # self.backend._get_metadata_from_event()
+        resource = f"Users/fake_tenant_id/Events/{organizer_event_fixture_parsed['id']}"
+        assert len(metadata_list) == 1
+        assert metadata_list[0][0] == activity_dto
+        assert metadata_list[0][1] == {
+            self.backend.METADATA_KEY: {
+                "resources": [resource],
+                "organizer_resource": resource,
+                "event_uid": organizer_event_fixture_parsed["uid"],
+                "event_id": organizer_event_fixture_parsed["id"],
+            }
+        }
+
+    @patch("wbcrm.synchronization.activity.backends.outlook.backend.MicrosoftGraphAPI")
+    def test_renew_web_hooks(self, mock_msgraph):
+        msgraph_fixture._subscription = {"id": "fake_id_new"}
+        mock_msgraph.return_value = msgraph_fixture()
+
+        user1 = UserFactory(is_superuser=True)
+        user2 = UserFactory(is_superuser=True)
+        user2.metadata = {self.backend.METADATA_KEY: {"subscription": {"id": "fake_id"}}}
+        user2.save()
+
+        self.backend.renew_web_hooks()
+        user1.refresh_from_db()
+        user2.refresh_from_db()
+        assert user1.metadata == {}
+        assert user2.metadata == {self.backend.METADATA_KEY: {"subscription": {"id": "fake_id_new"}}}

wbcrm/synchronization/activity/backends/outlook/tests/test_controller.py

@@ -0,0 +1,237 @@
+import itertools
+import json
+from unittest.mock import patch
+
+import pytest
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
+from dynamic_preferences.registries import global_preferences_registry
+from rest_framework.test import APIRequestFactory
+from wbcore.permissions.registry import user_registry
+from wbcrm.factories import ActivityFactory
+from wbcrm.models import Activity, ActivityParticipant
+from wbcrm.synchronization.activity.controller import ActivityController
+from wbcrm.typings import User as UserDTO
+
+from .fixtures import TestOutlookSyncFixture, msgraph_fixture
+
+User = get_user_model()
+
+
+@pytest.mark.django_db
+class TestInitController:
+    def test_init(self):
+        global_preferences_registry.manager()["wbactivity_sync__sync_backend_calendar"] = ""
+        controller = ActivityController()
+        assert controller.backend is None
+
+        global_preferences_registry.manager()[
+            "wbactivity_sync__sync_backend_calendar"
+        ] = "wbcrm.synchronization.activity.backends.outlook.backend.OutlookSyncBackend"
+        controller2 = ActivityController()
+        assert controller2.backend
+
+
+@pytest.mark.django_db
+class TestController(TestOutlookSyncFixture):
+    def setup_method(self):
+        global_preferences_registry.manager()[
+            "wbactivity_sync__sync_backend_calendar"
+        ] = "wbcrm.synchronization.activity.backends.outlook.backend.OutlookSyncBackend"
+
+    @pytest.fixture()
+    @patch("wbcrm.synchronization.activity.backends.outlook.backend.MicrosoftGraphAPI")
+    def controller(self, mock_msgraph):
+        controller = ActivityController()
+        controller.backend.open()
+        controller.backend.msgraph = msgraph_fixture()
+        return controller
+
+    def test_init(self):
+        controller = ActivityController()
+        assert controller.backend
+
+    @pytest.mark.parametrize("type_request", [None, "validationToken", "admin_consent"])
+    def test_handle_inbound_validation_response(self, controller, type_request):
+        request1 = APIRequestFactory().get("")
+        if type_request:
+            request1.GET = request1.GET.copy()
+            request1.GET[type_request] = "fake_info"
+            assert controller.handle_inbound_validation_response(request1).content.decode("UTF-8") == "fake_info"
+        else:
+            assert controller.handle_inbound_validation_response(request1) is None
+
+    @pytest.mark.parametrize("client_state", ["secret1", "secret2"])
+    @patch("wbcrm.synchronization.activity.backends.outlook.backend.MicrosoftGraphAPI")
+    def test_get_events_from_inbound_request(
+        self, mock_msgraph, controller, client_state, notification_fixture, teams_event_fixture
+    ):
+        notification_fixture["client_state"] = client_state
+        global_preferences_registry.manager()["wbactivity_sync__outlook_sync_client_state"] = "secret2"
+        api_factory = APIRequestFactory()
+        request1 = api_factory.post("", data={})
+        request2 = api_factory.post(
+            "", data=json.dumps({"value": [notification_fixture]}), content_type="application/json"
+        )
+
+        mock_msgraph.return_value = controller.backend.msgraph
+        controller.backend.msgraph.event = teams_event_fixture
+        controller.backend.msgraph.event_by_uid = teams_event_fixture
+        events1 = controller.get_events_from_inbound_request(request1)
+        events2 = controller.get_events_from_inbound_request(request2)
+        assert events1 == []
+        if client_state != global_preferences_registry.manager()["wbactivity_sync__outlook_sync_client_state"]:
+            assert events1 == events2 == []
+        else:
+            assert events1 == []
+            assert len(events2) == 1
+            expected_result = {
+                "change_type": notification_fixture["change_type"],
+                "resource": notification_fixture["resource"],
+                "subscription_id": notification_fixture["subscription_id"],
+                "organizer_resource": notification_fixture["resource"],
+                **teams_event_fixture,
+            }
+            assert set(events2[0].keys()) == set(expected_result.keys())
+
+    @patch("wbcrm.synchronization.activity.backends.outlook.backend.MicrosoftGraphAPI")
+    def test_user_for_handle_inbound(
+        self, mock_msgraph, controller, notification_fixture, teams_event_fixture, user_factory
+    ):
+        event = {
+            "change_type": notification_fixture["change_type"],
+            "resource": notification_fixture["resource"],
+            "subscription_id": notification_fixture["subscription_id"],
+            **teams_event_fixture,
+        }
+        metadata = {"outlook": {"subscription": {"id": notification_fixture["subscription_id"]}}}
+        _, _, user_dto = controller.backend._deserialize(event)
+        user_result = UserDTO(metadata=metadata, id=None)
+        assert user_dto.id is None
+        assert user_dto.metadata == user_result.metadata
+
+        assert controller.get_activity_participant(user_dto) is None
+        user = user_factory(is_active=True, is_superuser=True, metadata=metadata)
+        assert controller.get_activity_participant(user_dto) == user.profile
+
+    def _get_user_and_activities(self, notification_fixture, user_factory, teams_event_fixture):
+        user1 = user_factory(is_active=True)
+        user2 = user_factory(
+            is_active=True, metadata={"outlook": {"subscription": {"id": notification_fixture["subscription_id"]}}}
+        )
+
+        other1_activity = ActivityFactory(creator=user1.profile, participants=(user2.profile,))
+        other2_activity = ActivityFactory(
+            creator=user1.profile,
+            participants=(user2.profile,),
+            metadata={"outlook": {"event_id": 1, "event_uid": 2, "resources": ["Users/1/events/1"]}},
+        )
+        metadata = {
+            "outlook": {
+                "resources": [notification_fixture["resource"]],
+                "organizer_resource": notification_fixture["resource"],
+                "event_uid": teams_event_fixture["uid"],
+                "event_id": teams_event_fixture["id"],
+            }
+        }
+        activity = ActivityFactory(creator=user1.profile, participants=(user2.profile,))
+        Activity.objects.filter(id=activity.id).update(metadata=metadata)
+        return {"activities": (other1_activity, other2_activity, activity), "users": (user1, user2)}
+
+    @pytest.mark.parametrize("is_internal_creator, cancel_activity", list(itertools.product([True, False], repeat=2)))
+    def test_delete_activity(
+        self, cancel_activity, is_internal_creator, controller, notification_fixture, user_factory, teams_event_fixture
+    ):
+        global_preferences_registry.manager()["wbactivity_sync__sync_cancelled_activity"] = cancel_activity
+
+        data = self._get_user_and_activities(notification_fixture, user_factory, teams_event_fixture)
+        other1_activity, other2_activity, activity = data["activities"]
+        user1, user2 = data["users"]
+        if is_internal_creator:
+            permission = Permission.objects.get_or_create(
+                content_type=ContentType.objects.get_for_model(User), codename="is_internal_user"
+            )[0]
+            user1.user_permissions.add(permission)
+            user_registry.reset_cache()
+        activity.refresh_from_db()
+        activity_dto = activity._build_dto()
+
+        user1_dto = UserDTO(metadata=user1.metadata, id=None)
+        user2_dto = UserDTO(metadata=user2.metadata, id=None)
+
+        assert set(Activity.objects.all()) == {other1_activity, other2_activity, activity}
+
+        controller.delete_activity(activity_dto, user1_dto)
+        assert set(Activity.objects.all()) == {other1_activity, other2_activity, activity}
+
+        controller.delete_activity(
+            activity_dto, user2_dto
+        )  # user 2 is not the creator of the activity. it's a participant
+        assert set(Activity.objects.all()) == {other1_activity, other2_activity, activity}
+        if is_internal_creator:
+            assert (
+                activity.activity_participants.get(participant=user2.profile).participation_status
+                == ActivityParticipant.ParticipationStatus.CANCELLED
+            )
+
+        controller.delete_activity(
+            activity_dto, user1_dto
+        )  # user 1 is the creator of the activity but doesn't have an active subscription
+        assert set(Activity.objects.all()) == {other1_activity, other2_activity, activity}
+        user1.metadata = user2.metadata
+        user1.save()
+        user2.metadata = {}
+        user2.metadata = {"outlook": {"subscription": {"id": "new_subscription1"}}}
+        user2.save()
+        user1.refresh_from_db()
+        user1_dto = UserDTO(metadata=user1.metadata, id=None)
+
+        controller.delete_activity(
+            activity_dto, user1_dto
+        )  # user 1 is the creator of the activity with an active subscription
+        if is_internal_creator and not cancel_activity:
+            assert set(Activity.objects.all()) == {other1_activity, other2_activity}
+        else:
+            assert set(Activity.objects.all()) == {other1_activity, other2_activity, activity}
+        assert set(Activity.all_objects.all()) == {other1_activity, other2_activity, activity}
+
+    @pytest.mark.parametrize(
+        "cancel_external_creator_activity, cancel_activity", list(itertools.product([True, False], repeat=2))
+    )
+    def test_cancel_no_participant_external_creator_activity(
+        self,
+        cancel_external_creator_activity,
+        cancel_activity,
+        controller,
+        notification_fixture,
+        user_factory,
+        teams_event_fixture,
+    ):
+        global_preferences_registry.manager()["wbactivity_sync__sync_cancelled_activity"] = cancel_activity
+        global_preferences_registry.manager()[
+            "wbactivity_sync__sync_cancelled_external_activity"
+        ] = cancel_external_creator_activity
+
+        data = self._get_user_and_activities(notification_fixture, user_factory, teams_event_fixture)
+        other1_activity, other2_activity, activity = data["activities"]
+        user1, user2 = data["users"]
+        permission = Permission.objects.get_or_create(
+            content_type=ContentType.objects.get_for_model(User), codename="is_internal_user"
+        )[0]
+        user2.user_permissions.add(permission)
+        user_registry.reset_cache()
+        user2_dto = UserDTO(metadata=user2.metadata, id=None)
+        Activity.objects.filter(id=activity.id).update(creator=user1.profile)
+        activity.refresh_from_db()
+        activity_dto = activity._build_dto()
+
+        assert set(Activity.objects.all()) == {other1_activity, other2_activity, activity}
+
+        # user 1 is an external user and it's the creator of the activity without an active subscription
+        # user 2 is a internal participant
+        controller.delete_activity(activity_dto, user2_dto)
+        if cancel_external_creator_activity and not cancel_activity:
+            assert set(Activity.objects.all()) == {other1_activity, other2_activity}
+        else:
+            assert set(Activity.objects.all()) == {other1_activity, other2_activity, activity}