wbcrm 2.2.1__py2.py3-none-any.whl

wbcrm/tests/test_models.py

@@ -0,0 +1,216 @@
+from datetime import timedelta
+
+import pytest
+from django.apps import apps
+from django.utils import timezone
+from django_fsm import TransitionNotAllowed
+from dynamic_preferences.registries import global_preferences_registry
+from wbcore.contrib.agenda.models import CalendarItem
+from wbcore.contrib.authentication.factories import (
+    AuthenticatedPersonFactory,
+    UserFactory,
+)
+from wbcore.contrib.directory.factories import PersonWithEmployerFactory
+from wbcore.contrib.directory.models import Entry
+from wbcore.contrib.icons import WBIcon
+from wbcrm.models import Activity, add_employer_to_activities
+
+
+@pytest.mark.django_db
+class TestSpecificModelsActivities:
+    def test_get_color_map(self, activity_factory):
+        activity1 = activity_factory()
+        assert activity1.Status.get_color_map()
+
+    def test_get_minutes_correspondance(self, activity_factory):
+        activity1 = activity_factory()
+        assert activity1.ReminderChoice.get_minutes_correspondance("NEVER")
+        assert activity1.ReminderChoice.get_minutes_correspondance("EVENT_TIME") == 0
+        assert activity1.ReminderChoice.get_minutes_correspondance("MINUTES_5")
+        assert activity1.ReminderChoice.get_minutes_correspondance("MINUTES_15")
+        assert activity1.ReminderChoice.get_minutes_correspondance("MINUTES_30")
+        assert activity1.ReminderChoice.get_minutes_correspondance("HOURS_1")
+        assert activity1.ReminderChoice.get_minutes_correspondance("HOURS_2")
+        assert activity1.ReminderChoice.get_minutes_correspondance("HOURS_12")
+        assert activity1.ReminderChoice.get_minutes_correspondance("WEEKS_1")
+
+    def test_str(self, activity_factory):
+        assert activity_factory(preceded_by=None).__str__()
+
+    def test_get_participants(self, activity_factory, person_factory, internal_user_factory, company_factory):
+        person1 = person_factory()
+        company1 = company_factory()
+        if apps.is_installed("wbhuman_resources"):
+            from wbhuman_resources.factories import EmployeeHumanResourceFactory
+
+            person2 = AuthenticatedPersonFactory(employers=(company1,))
+            EmployeeHumanResourceFactory(profile=person2)
+        else:
+            person2 = person_factory(employers=(company1,))
+            u = internal_user_factory.create()
+            u.profile = person2
+            u.save()
+        activity1 = activity_factory(participants=(person1,))
+        assert activity1.get_participants().count() == 1
+        assert activity1.get_participants()[0] == person1
+
+    def test_get_activities_for_user(self, activity_factory):
+        activity0 = activity_factory(preceded_by=None)
+        user = UserFactory(is_active=True, is_superuser=True)
+        qs = activity0.get_activities_for_user(user)
+        assert qs.count() == 1
+
+        user2 = UserFactory(is_active=True)
+        qs2 = activity0.get_activities_for_user(user2)
+        assert qs2.count() == 0
+
+    def test_add_group_to_activity(self, activity_factory, group_factory, person_factory, company_factory):
+        activity_participant_a = person_factory()
+        group_member_a = person_factory()
+        member_a_entry = Entry.objects.get(pk=group_member_a.pk)
+        group_member_b = company_factory()
+        member_b_entry = Entry.objects.get(pk=group_member_b.pk)
+        group_a = group_factory(members=(member_a_entry, member_b_entry))
+
+        activity = activity_factory(
+            participants=[
+                activity_participant_a,
+            ]
+        )
+        assert activity.participants.filter(pk=activity_participant_a.pk).exists()
+        assert not activity.participants.filter(pk=group_member_a.pk).exists()
+        assert not activity.companies.filter(pk=group_member_b.pk).exists()
+
+        activity.groups.set((group_a,))
+        activity.save()
+
+        assert activity.participants.filter(pk=activity_participant_a.pk).exists()
+        assert activity.participants.filter(pk=group_member_a.pk).exists()
+        assert activity.companies.filter(pk=group_member_b.pk).exists()
+
+    def test_remove_group_to_activity(self, activity_factory, group_factory, person_factory, company_factory):
+        group_member_a = person_factory()
+        group_member_b = person_factory()
+        group_member_c = person_factory()
+        group_member_d = company_factory()
+        group_a = group_factory(members=(group_member_a.entry_ptr, group_member_c.entry_ptr, group_member_d.entry_ptr))
+        group_b = group_factory(members=(group_member_b.entry_ptr, group_member_c.entry_ptr))
+
+        activity = activity_factory(groups=[group_a, group_b])
+
+        assert activity.participants.filter(pk=group_member_a.pk).exists()
+        assert activity.participants.filter(pk=group_member_b.pk).exists()
+        assert activity.participants.filter(pk=group_member_c.pk).exists()
+        assert activity.companies.filter(pk=group_member_d.pk).exists()
+
+        activity.groups.remove(group_a.pk)
+        activity.save()
+
+        assert not activity.participants.filter(pk=group_member_a.pk).exists()
+        assert activity.participants.filter(pk=group_member_b.pk).exists()
+        assert activity.participants.filter(pk=group_member_c.pk).exists()
+        assert not activity.companies.filter(pk=group_member_d.pk).exists()
+
+    def test_add_participants_employer(self, activity_factory, person_factory):
+        person_a = PersonWithEmployerFactory()
+        person_b = person_factory()
+        employer_a = person_a.employer.get(primary=True).employer
+        activity_a = activity_factory(participants=(person_a, person_b))
+        assert person_a in activity_a.participants.all()
+        assert person_b in activity_a.participants.all()
+        assert employer_a in activity_a.companies.all()
+
+    def test_add_participants_employer_on_update(self, activity_factory, person_factory):
+        person_a = PersonWithEmployerFactory()
+        person_b = person_factory()
+        employer_a = person_a.employer.get(primary=True).employer
+        activity_a = activity_factory(participants=(person_b,))
+        assert person_a not in activity_a.participants.all()
+        assert person_b in activity_a.participants.all()
+        assert employer_a not in activity_a.companies.all()
+        activity_a.participants.set([person_a, person_b])
+        assert person_a in activity_a.participants.all()
+        assert person_b in activity_a.participants.all()
+        assert employer_a in activity_a.companies.all()
+
+    def test_add_participants_employer_to_canceled_activity(self, activity_factory, person_factory):
+        person_a = PersonWithEmployerFactory()
+        person_b = person_factory()
+        activity_a = activity_factory(participants=(person_a, person_b), status=Activity.Status.CANCELLED)
+        assert set(activity_a.participants.all()) == {person_a, person_b}
+
+    def test_participant_cannot_attend_digitally(
+        self, activity_participant_factory, activity_factory, conference_room_factory
+    ):
+        room = conference_room_factory(is_videoconference_capable=False)
+        activity = activity_factory(conference_room=room)
+        obj = activity_participant_factory(activity=activity)
+        with pytest.raises(TransitionNotAllowed):
+            obj.attendsdigitally()
+
+    def test_participant_can_attend_digitally(self, activity_participant_factory, activity_factory):
+        activity = activity_factory()
+        obj = activity_participant_factory(activity=activity)
+        obj.attendsdigitally()
+        assert True
+
+    def test_get_casted_calendar_item(self, activity_factory):
+        activity = activity_factory()
+        calendar_item = CalendarItem.objects.get(id=activity.id)
+        assert calendar_item.get_casted_calendar_item() == activity
+
+    def test_add_employer_to_activities(
+        self, activity_factory, employer_employee_relationship_factory, person_factory
+    ):
+        employee = person_factory()
+        act1 = activity_factory(
+            status=Activity.Status.PLANNED, start=timezone.now() + timedelta(1), participants=[employee]
+        )
+        act2 = activity_factory(
+            status=Activity.Status.REVIEWED, start=timezone.now() + timedelta(1), participants=[employee]
+        )
+        act3 = activity_factory(
+            status=Activity.Status.PLANNED, start=timezone.now() - timedelta(1), participants=[employee]
+        )
+        eer = employer_employee_relationship_factory(employee=employee)
+        add_employer_to_activities(eer.id)
+        act1.refresh_from_db()
+        act2.refresh_from_db()
+        act3.refresh_from_db()
+        assert eer.employer in act1.companies.all()
+        assert eer.employer not in act2.companies.all()
+        assert eer.employer not in act3.companies.all()
+        assert eer.employer.entry_ptr in act1.entities.all()
+        assert eer.employer.entry_ptr not in act2.entities.all()
+        assert eer.employer.entry_ptr not in act3.entities.all()
+
+    def test_set_color_icons(self, activity_factory, calendar_item_factory):
+        activity = activity_factory(type__icon=WBIcon.EURO.icon)
+        assert activity.color == activity.type.color
+        assert activity.icon == activity.type.icon
+
+        activity_type = activity.type
+        activity_type.icon = WBIcon.LOCATION.icon
+        activity_type.color = "#42f444"
+        activity_type.save()
+        activity.refresh_from_db()
+        assert activity.color == activity_type.color
+        assert activity.icon == activity_type.icon
+
+        calendar_item = calendar_item_factory()
+        assert calendar_item.color
+        assert calendar_item.icon
+
+    def test_main_company_removed_from_m2m(self, activity, company_factory):
+        external_company = company_factory.create()
+        activity.companies.add(external_company)
+        assert set(activity.companies.all()) == {
+            external_company,
+        }
+
+        main_company = company_factory.create()
+        global_preferences_registry.manager()["directory__main_company"] = main_company.id
+        activity.companies.add(main_company)
+        assert set(activity.companies.all()) == {
+            external_company,
+        }

wbcrm/tests/test_recurrence.py

@@ -0,0 +1,291 @@
+import pytest
+from django.db.models import Q
+from django.forms.models import model_to_dict
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.messages import InMemoryMessageStorage
+from wbcrm.models.activities import Activity
+from wbcrm.models.recurrence import Recurrence
+from wbcrm.preferences import (
+    get_maximum_allowed_recurrent_date,
+    get_recurrence_maximum_count,
+)
+from wbcrm.serializers import ActivityModelSerializer
+from wbcrm.viewsets import ActivityViewSet
+
+
+@pytest.mark.django_db
+class RecurrenceFixture:
+    @pytest.fixture
+    def occurrence_fixture(self, activity_factory):
+        return activity_factory(repeat_choice=Recurrence.ReoccuranceChoice.DAILY, recurrence_count=3, preceded_by=None)
+
+    @pytest.fixture
+    def occurrences_fixture(self, occurrence_fixture):
+        return Activity.objects.filter(Q(id=occurrence_fixture.id) | Q(parent_occurrence=occurrence_fixture)).order_by(
+            "start"
+        )
+
+
+@pytest.mark.django_db
+class TestRecurrenceModel(RecurrenceFixture):
+    @pytest.mark.parametrize("repeat_choice", [*list(Recurrence.ReoccuranceChoice)])
+    def test_is_recurrent(self, repeat_choice, recurring_activity_factory):
+        act = recurring_activity_factory(repeat_choice=repeat_choice)
+        assert act.is_recurrent == (act.repeat_choice != Recurrence.ReoccuranceChoice.NEVER)
+
+    def test_recurring_activity_without_end(self, recurring_activity_factory):
+        act = recurring_activity_factory(repeat_choice=Recurrence.ReoccuranceChoice.DAILY, recurrence_count=None)
+        occurrences = Activity.objects.filter(parent_occurrence=act)
+        assert occurrences.count() <= get_recurrence_maximum_count()
+        assert (
+            occurrences.order_by("period__startswith").last().period.lower.date()
+            <= get_maximum_allowed_recurrent_date()
+        )
+
+    def test_is_root(self, occurrences_fixture):
+        for occurrence in occurrences_fixture:
+            assert occurrence.is_root == (occurrence.is_recurrent and not occurrence.parent_occurrence)
+
+    def test_is_leaf(self, occurrences_fixture):
+        for occurrence in occurrences_fixture:
+            assert occurrence.is_leaf == (occurrence.is_recurrent and not occurrence.next_occurrence)
+
+    def test_next_occurrence(self, occurrences_fixture):
+        last_row = len(occurrences_fixture) - 1
+        for row, occurrence in enumerate(occurrences_fixture):
+            if row == last_row:
+                assert occurrence.next_occurrence is None
+            else:
+                assert occurrence.next_occurrence == occurrences_fixture[row + 1]
+
+    def test_previous_occurrence(self, occurrences_fixture):
+        for row, occurrence in enumerate(occurrences_fixture):
+            if row == 0:
+                assert occurrence.previous_occurrence is None
+            else:
+                assert occurrence.previous_occurrence == occurrences_fixture[row - 1]
+
+    # def test_get_recurrent_valid_children(self, occurrences_fixture):
+    #     parent = occurrences_fixture[0]
+    #     assert parent.get_recurrent_valid_children().count() == len(occurrences_fixture[1:])
+    #     assert parent.get_recurrent_invalid_children().count() == 0
+    #     occurrences_fixture[1].cancel()
+    #     assert parent.get_recurrent_valid_children().count() == len(occurrences_fixture[1:]) - 1
+    #     assert parent.get_recurrent_invalid_children().count() == 1
+    #     occurrences_fixture[2].review()
+    #     assert parent.get_recurrent_valid_children().count() == len(occurrences_fixture[1:]) - 2
+    #     assert parent.get_recurrent_invalid_children().count() == 2
+    #     occurrences_fixture[3].finish()
+    #     assert parent.get_recurrent_valid_children().count() == len(occurrences_fixture[1:]) - 3
+    #     assert parent.get_recurrent_invalid_children().count() == 3
+
+    @pytest.mark.parametrize("position, only_next_occurrence", [(0, False), (0, True), (1, False), (1, True)])
+    def test_forward_deletion(self, occurrences_fixture, only_next_occurrence, position):
+        nb_activities = Activity.objects.count()
+        occ = occurrences_fixture[position]
+        next_occurrences = occurrences_fixture.filter(period__startswith__gt=occ.period.lower)
+        next_occ = next_occurrences.first()
+        nb_next_occurrences = next_occurrences.count()
+        assert nb_activities == 4
+        if only_next_occurrence:
+            occ.forward_deletion([next_occ.id])
+            assert Activity.objects.count() == nb_activities - 1 == 3
+        else:
+            occ.forward_deletion()
+            assert Activity.objects.count() == nb_activities - nb_next_occurrences
+
+    def test_claim_parent_hood(self, occurrences_fixture, activity_factory):
+        single_activity = activity_factory(repeat_choice=Recurrence.ReoccuranceChoice.NEVER, preceded_by=None)
+        single_activity.claim_parent_hood()
+        assert single_activity.is_root is False
+
+        for occurrence in occurrences_fixture:
+            occurrence.claim_parent_hood()
+            if occurrence.is_leaf:
+                assert occurrence.is_root is False
+            else:
+                assert occurrence.is_root is True
+
+    @pytest.mark.parametrize("position, propagation", [(0, False), (0, True), (1, False), (1, True)])
+    def test_delete(self, position, propagation, occurrences_fixture):
+        occ = occurrences_fixture[position]
+        next_occurrences = occurrences_fixture.filter(period__startswith__gt=occ.period.lower)
+        next_occ = next_occurrences.first()
+        nb_next_occurrences = next_occurrences.count()
+        assert Activity.objects.count() == len(occurrences_fixture) == 4
+        assert nb_next_occurrences == 3 - position
+        Activity.objects.filter(id=occ.id).update(propagate_for_all_children=propagation)
+        occ.refresh_from_db()
+        was_root = True if occ.is_root else False
+        occ.delete()
+        if propagation:
+            assert Activity.objects.count() == 3 - nb_next_occurrences
+        else:
+            assert Activity.objects.count() == 3
+            next_occ.refresh_from_db()
+            next_occ.is_root == was_root
+
+    @pytest.mark.parametrize("include_self", [False, True])
+    def test_get_occurrence_start_datetimes(self, occurrences_fixture, include_self, activity_factory):
+        single_activity = activity_factory(repeat_choice=Recurrence.ReoccuranceChoice.NEVER, preceded_by=None)
+        assert not single_activity._get_occurrence_start_datetimes(include_self)
+        assert single_activity.is_root is False
+
+        start_dates = occurrences_fixture[0]._get_occurrence_start_datetimes(include_self)
+        nb_occurrences = len(occurrences_fixture) if include_self else len(occurrences_fixture[1:])
+        assert len(start_dates) == nb_occurrences
+
+    def test_create_recurrence_child(self, occurrence_fixture):
+        nb_activities = Activity.objects.count()
+        start_dates = occurrence_fixture._get_occurrence_start_datetimes()
+        new_occurrence = occurrence_fixture._create_recurrence_child(start_dates[0])
+        assert Activity.objects.count() == nb_activities + 1
+        fields = [
+            "assigned_to",
+            "all_day",
+            "conference_room",
+            "creator",
+            "description",
+            "disable_participant_check",
+            "importance",
+            "visibility",
+            "location",
+            "location_longitude",
+            "location_latitude",
+            "recurrence_end",
+            "recurrence_count",
+            "reminder_choice",
+            "repeat_choice",
+            "title",
+            "type",
+        ]
+        assert new_occurrence.period.lower == start_dates[0]
+        assert occurrence_fixture.duration == new_occurrence.duration
+        assert new_occurrence.parent_occurrence == occurrence_fixture
+        assert model_to_dict(occurrence_fixture, fields=fields) == model_to_dict(new_occurrence, fields=fields)
+
+    def test_generate_occurrences(self, occurrence_fixture, activity_factory):
+        single_activity = activity_factory(repeat_choice=Recurrence.ReoccuranceChoice.NEVER, preceded_by=None)
+        assert len(single_activity.generate_occurrences()) == 0
+        children = occurrence_fixture.generate_occurrences().order_by("period__startswith")
+        assert (
+            len(children)
+            == len(occurrence_fixture._get_occurrence_start_datetimes())
+            == occurrence_fixture.recurrence_count
+        )
+        assert set(children) == set(occurrence_fixture.child_activities.all())
+        assert children[0].is_root is False
+        assert len(children[0].generate_occurrences(allow_reclaiming_root=False)) == 0
+        assert children[0].is_root is False
+        assert len(children[0].generate_occurrences()) == children[0].recurrence_count > 0
+        assert children[0].is_root is True
+        assert children[0].child_activities.all().count() == children[0].recurrence_count
+        assert occurrence_fixture.child_activities.all().count() == 0
+
+    @pytest.mark.parametrize("position_occurrence, propagation", [(0, False), (0, True), (1, False), (1, True)])
+    def test_forward_change(self, occurrences_fixture, propagation, position_occurrence, activity_factory):
+        activity = occurrences_fixture[position_occurrence]
+        nb_next_occurrences = len(occurrences_fixture[position_occurrence + 1 :])
+        if activity.is_root:
+            assert len(activity.get_recurrent_valid_children()) == nb_next_occurrences
+        else:
+            assert len(activity.get_recurrent_valid_children()) == 0
+        was_root = activity.is_root
+        other_activity = activity_factory(preceded_by=None)
+        Activity.objects.filter(id=activity.id).update(
+            title=other_activity.title, propagate_for_all_children=propagation
+        )
+        activity.refresh_from_db()
+        activity.forward_change()
+        activity.refresh_from_db()
+        assert activity.is_root == (propagation or was_root)
+        assert activity.propagate_for_all_children is False
+        if propagation or was_root:
+            assert len(activity.get_recurrent_valid_children()) == nb_next_occurrences
+        else:
+            assert len(activity.get_recurrent_valid_children()) == 0
+
+
+@pytest.mark.django_db
+class TestRecurrenceSerializers(RecurrenceFixture):
+    def test_next_occurrence_no_period(self, activity_factory):
+        activity = activity_factory(
+            period=None, repeat_choice=Recurrence.ReoccuranceChoice.DAILY, recurrence_count=3, preceded_by=None
+        )
+        request = APIRequestFactory().get("")
+        user = UserFactory()
+        request.user = user
+        request.parser_context = {}
+        serializer = ActivityModelSerializer(activity, context={"request": request})
+        assert serializer.next_occurrence(activity, request, user)
+
+    def test_previous_occurrence_no_period(self, activity_factory):
+        activity = activity_factory(
+            period=None, repeat_choice=Recurrence.ReoccuranceChoice.DAILY, recurrence_count=3, preceded_by=None
+        )
+        request = APIRequestFactory().get("")
+        user = UserFactory()
+        request.user = user
+        request.parser_context = {}
+        serializer = ActivityModelSerializer(activity, context={"request": request})
+        assert not serializer.previous_occurrence(activity, request, user)
+
+    def test_next_occurrence(self, occurrences_fixture):
+        request = APIRequestFactory().get("")
+        user = UserFactory()
+        request.user = user
+        request.parser_context = {}
+        last_row = len(occurrences_fixture) - 1
+        for row, occurrence in enumerate(occurrences_fixture):
+            serializer_occurrence = ActivityModelSerializer(occurrence, context={"request": request})
+            if row == last_row:
+                assert not serializer_occurrence.next_occurrence(occurrence, request, user)
+            else:
+                assert serializer_occurrence.next_occurrence(occurrence, request, user) == {
+                    "next_occurrence": f"http://testserver/api/crm/activity/{occurrences_fixture[row+1].id}/"
+                }
+
+    def test_previous_occurrence(self, occurrences_fixture):
+        request = APIRequestFactory().get("")
+        user = UserFactory()
+        request.user = user
+        request.parser_context = {}
+        for row, occurrence in enumerate(occurrences_fixture):
+            serializer_occurrence = ActivityModelSerializer(occurrence, context={"request": request})
+            if row == 0:
+                assert not serializer_occurrence.previous_occurrence(occurrence, request, user)
+            else:
+                assert serializer_occurrence.previous_occurrence(occurrence, request, user) == {
+                    "previous_occurrence": f"http://testserver/api/crm/activity/{occurrences_fixture[row-1].id}/"
+                }
+
+
+@pytest.mark.django_db
+class TestRecurrenceViewSets(RecurrenceFixture):
+    def test_next_and_previous_activity_button_present_for_recurring_activity(
+        self, occurrences_fixture, super_user_factory
+    ):
+        request = APIRequestFactory().get("")
+        request.user = super_user_factory()
+        request._messages = InMemoryMessageStorage(request)
+        view = ActivityViewSet.as_view({"get": "retrieve"})
+        for row, occurrence in enumerate(occurrences_fixture):
+            response = view(request, pk=occurrence.id).render()
+            if occurrence.is_root:
+                assert response.data["instance"]["_additional_resources"]["next_occurrence"].endswith(
+                    str(occurrences_fixture[row + 1].id) + "/"
+                )
+                assert "previous_occurrence" not in response.data["instance"]["_additional_resources"]
+            elif occurrence.is_leaf:
+                assert "next_occurrence" not in response.data["instance"]["_additional_resources"]
+                assert response.data["instance"]["_additional_resources"]["previous_occurrence"].endswith(
+                    str(occurrences_fixture[row - 1].id) + "/"
+                )
+            else:
+                assert response.data["instance"]["_additional_resources"]["next_occurrence"].endswith(
+                    str(occurrences_fixture[row + 1].id) + "/"
+                )
+                assert response.data["instance"]["_additional_resources"]["previous_occurrence"].endswith(
+                    str(occurrences_fixture[row - 1].id) + "/"
+                )

wbcrm/tests/test_report.py

@@ -0,0 +1,20 @@
+import pytest
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcrm.report.activity_report import create_report, create_report_and_send
+
+
+@pytest.mark.django_db
+class TestSpecificReport:
+    def test_create_report(self, person_factory, activity_factory):
+        person = person_factory()
+        activity = activity_factory(participants=(person,))
+        report = create_report(person.id, activity.start, activity.end)
+        assert report
+        assert report.getvalue()
+
+    def test_create_report_and_send(self, person_factory):
+        request = APIRequestFactory().get("")
+        request.user = UserFactory(is_active=True, is_superuser=True)
+        person = person_factory()
+        create_report_and_send(request.user.profile.id, person.id)