social/mail_activity_reminder/tests/test_mail_activity_reminder.py

# Copyright 2020 Brainbean Apps (https://brainbeanapps.com)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).

from datetime import datetime

from dateutil.relativedelta import relativedelta
from freezegun import freeze_time

from odoo.tests import common


class TestMailActivityReminder(common.SavepointCase):
    @classmethod
    def setUpClass(cls):
        super().setUpClass()

        cls.env = cls.env(
            context=dict(
                cls.env.context, tracking_disable=True, no_reset_password=True,
            )
        )
        cls.ResUsers = cls.env["res.users"]
        cls.Company = cls.env["res.company"]
        cls.MailActivityType = cls.env["mail.activity.type"]
        cls.MailActivity = cls.env["mail.activity"]
        cls.company_id = cls.Company._company_default_get()
        cls.now = datetime(2020, 4, 19, 15, 00)
        cls.today = cls.now.date()
        cls.model_res_partner = cls.env["ir.model"].search(
            [("model", "=", "res.partner")], limit=1
        )
        cls.partner_DecoAddict = cls.env["res.partner"].search(
            [("name", "ilike", "Deco Addict")], limit=1
        )

    def test_none_reminders(self):
        activity_type = self.MailActivityType.create({"name": "Activity Type"})
        self.assertEqual(activity_type._get_reminder_offsets(), [])

    def test_empty_reminders(self):
        activity_type = self.MailActivityType.create(
            {"name": "Activity Type", "reminders": " -./"}
        )
        self.assertEqual(activity_type._get_reminder_offsets(), [])

    def test_delimiters(self):
        activity_type = self.MailActivityType.create(
            {"name": "Activity Type", "reminders": "0 1_2/3.4t5"}
        )
        self.assertEqual(activity_type._get_reminder_offsets(), [0, 1, 2, 3, 4, 5])

    def test_first_notice_is_reminder(self):
        activity_type = self.MailActivityType.create(
            {"name": "Activity Type", "reminders": "0"}
        )
        user = self.ResUsers.sudo().create(
            {
                "name": "User",
                "login": "user",
                "email": "user@example.com",
                "company_id": self.company_id.id,
            }
        )
        activity = self.MailActivity.create(
            {
                "summary": "Activity",
                "activity_type_id": activity_type.id,
                "res_model_id": self.model_res_partner.id,
                "res_id": self.partner_DecoAddict.id,
                "date_deadline": self.today,
                "user_id": user.id,
            }
        )

        self.assertTrue(activity.last_reminder_local)

    def test_reminder_behaviour(self):
        activity_type = self.MailActivityType.create(
            {"name": "Activity Type", "reminders": "0/2"}
        )

        with freeze_time(self.now):
            activity = self.MailActivity.create(
                {
                    "summary": "Activity",
                    "activity_type_id": activity_type.id,
                    "res_model_id": self.model_res_partner.id,
                    "res_id": self.partner_DecoAddict.id,
                    "date_deadline": self.today + relativedelta(days=5),
                }
            )

        with freeze_time(self.now):
            activities = self.MailActivity._get_activities_to_remind()
            self.assertFalse(activities)

        with freeze_time(self.now + relativedelta(days=2)):
            activities = self.MailActivity._get_activities_to_remind()
            self.assertFalse(activities)

        with freeze_time(self.now + relativedelta(days=3)):
            activities = self.MailActivity._get_activities_to_remind()
            self.assertEqual(activities, activity)
            activities.action_remind()

        with freeze_time(self.now + relativedelta(days=4)):
            activities = self.MailActivity._get_activities_to_remind()
            self.assertFalse(activities)

        with freeze_time(self.now + relativedelta(days=5)):
            activities = self.MailActivity._get_activities_to_remind()
            self.assertEqual(activities, activity)
            activities.action_remind()

        activity.active = False
        with freeze_time(self.now + relativedelta(days=5)):
            activities = self.MailActivity._get_activities_to_remind()
            self.assertFalse(activities)

    def test_reminder_flow(self):
        activity_type = self.MailActivityType.create(
            {"name": "Activity Type", "reminders": "0/2"}
        )

        with freeze_time(self.now):
            activity = self.MailActivity.create(
                {
                    "summary": "Activity",
                    "activity_type_id": activity_type.id,
                    "res_model_id": self.model_res_partner.id,
                    "res_id": self.partner_DecoAddict.id,
                    "date_deadline": self.today + relativedelta(days=5),
                }
            )

        with freeze_time(self.now):
            activities = self.MailActivity._process_reminders()
            self.assertFalse(activities)

        with freeze_time(self.now + relativedelta(days=2)):
            activities = self.MailActivity._process_reminders()
            self.assertFalse(activities)

        with freeze_time(self.now + relativedelta(days=3)):
            activities = self.MailActivity._process_reminders()
            self.assertEqual(activities, activity)

        with freeze_time(self.now + relativedelta(days=4)):
            activities = self.MailActivity._process_reminders()
            self.assertFalse(activities)

        with freeze_time(self.now + relativedelta(days=5)):
            activities = self.MailActivity._process_reminders()
            self.assertEqual(activities, activity)

    def test_repeated_reminder(self):
        activity_type = self.MailActivityType.create(
            {"name": "Activity Type", "reminders": "0"}
        )

        with freeze_time(self.now):
            activity = self.MailActivity.create(
                {
                    "summary": "Activity",
                    "activity_type_id": activity_type.id,
                    "res_model_id": self.model_res_partner.id,
                    "res_id": self.partner_DecoAddict.id,
                    "date_deadline": self.today + relativedelta(days=1),
                }
            )

        with freeze_time(self.now + relativedelta(days=1)):
            activities = self.MailActivity._process_reminders()
            self.assertEqual(activities, activity)

            activities = self.MailActivity._process_reminders()
            self.assertFalse(activities)

    def test_overdue_reminder(self):
        activity_type = self.MailActivityType.create(
            {"name": "Activity Type", "reminders": "0"}
        )

        with freeze_time(self.now):
            self.MailActivity.create(
                {
                    "summary": "Activity",
                    "activity_type_id": activity_type.id,
                    "res_model_id": self.model_res_partner.id,
                    "res_id": self.partner_DecoAddict.id,
                    "date_deadline": self.today + relativedelta(days=1),
                }
            )

        with freeze_time(self.now + relativedelta(days=2)):
            activities = self.MailActivity._get_activities_to_remind()
            self.assertFalse(activities)