[IMP] event: improve some type -> event configuration tests

Purpose of this commit is to add some tests related to event_type to event
configuration. Indeed changing a type on an event may change its sub models
(mails, tickets, questions). Asserting current behavior is necessary before
tweaking behavior considered as to be improved.

Task ID 2244487
PR odoo/odoo#52998
FwdPort of odoo/odoo#52923

X-original-commit: 6fb42e70164bab05681b11f1e76e320db0266445

2 files changed, 107 insertions, 47 deletions

diff --git a/addons/event/tests/common.py b/addons/event/tests/common.py
index 126a839805f..f89f486439b 100644
--- a/addons/event/tests/common.py
+++ b/addons/event/tests/common.py
@@ -92,7 +92,7 @@ class TestEventCommon(common.SavepointCase):
             'date_tz': 'Europe/Brussels',
         })
 
-        # set country in order to format belgium numbers
+        # set country in order to format Belgian numbers
         cls.event_0.company_id.write({'country_id': cls.env.ref('base.be').id})
 
     @classmethod
diff --git a/addons/event/tests/test_event_internals.py b/addons/event/tests/test_event_internals.py
index 9a8d4147d81..bd7e537f75f 100644
--- a/addons/event/tests/test_event_internals.py
+++ b/addons/event/tests/test_event_internals.py
@@ -70,62 +70,24 @@ class TestEventData(TestEventCommon):
         self.assertFalse(event.is_ongoing)
 
     @users('user_eventmanager')
-    def test_event_fields(self):
-        event_type = self.event_type_complex.with_user(self.env.user)
-        event = self.env['event.event'].create({
-            'name': 'Event Update Type',
-            'event_type_id': event_type.id,
-            'date_begin': FieldsDatetime.to_string(datetime.today() + timedelta(days=1)),
-            'date_end': FieldsDatetime.to_string(datetime.today() + timedelta(days=15)),
-        })
-
-        self.assertEqual(event.address_id, self.env.user.company_id.partner_id)
-        # seats: coming from event type configuration
-        self.assertTrue(event.seats_limited)
-        self.assertEqual(event.seats_available, event.event_type_id.seats_max)
-        self.assertEqual(event.seats_unconfirmed, 0)
-        self.assertEqual(event.seats_reserved, 0)
-        self.assertEqual(event.seats_used, 0)
-        self.assertEqual(event.seats_expected, 0)
-
-        # create registration in order to check the seats computation
-        self.assertTrue(event.auto_confirm)
-        for x in range(5):
-            reg = self.env['event.registration'].create({
-                'event_id': event.id,
-                'name': 'reg_open',
-            })
-            self.assertEqual(reg.state, 'open')
-        reg_draft = self.env['event.registration'].create({
-            'event_id': event.id,
-            'name': 'reg_draft',
-        })
-        reg_draft.write({'state': 'draft'})
-        reg_done = self.env['event.registration'].create({
-            'event_id': event.id,
-            'name': 'reg_done',
-        })
-        reg_done.write({'state': 'done'})
-        self.assertEqual(event.seats_available, event.event_type_id.seats_max - 6)
-        self.assertEqual(event.seats_unconfirmed, 1)
-        self.assertEqual(event.seats_reserved, 5)
-        self.assertEqual(event.seats_used, 1)
-        self.assertEqual(event.seats_expected, 7)
-
-    @users('user_eventmanager')
     @mute_logger('odoo.models.unlink')
     def test_event_configuration_from_type(self):
         """ Test data computation of event coming from its event.type template.
         Some one2many notably are duplicated from type configuration and some
         advanced testing is required, notably mail schedulers. """
-
         self.assertEqual(self.env.user.tz, 'Europe/Brussels')
 
-        event_type = self.event_type_complex.with_user(self.env.user)
+        # ------------------------------------------------------------
+        # STARTING DATA
+        # ------------------------------------------------------------
+
+        event_type = self.env['event.type'].browse(self.event_type_complex.id)
         event_type.write({
             'use_mail_schedule': False,
+            'use_ticket': False,
         })
         self.assertEqual(event_type.event_type_mail_ids, self.env['event.type.mail'])
+        self.assertEqual(event_type.event_type_ticket_ids, self.env['event.type.ticket'])
 
         event = self.env['event.event'].create({
             'name': 'Event Update Type',
@@ -136,22 +98,77 @@ class TestEventData(TestEventCommon):
         self.assertFalse(event.seats_limited)
         self.assertFalse(event.auto_confirm)
         self.assertEqual(event.event_mail_ids, self.env['event.mail'])
+        self.assertEqual(event.event_ticket_ids, self.env['event.event.ticket'])
 
+        registration = self._create_registrations(event, 1)
+        self.assertEqual(registration.state, 'draft')  # event is not auto confirm
+
+        # ------------------------------------------------------------
+        # FILL SYNC TEST
+        # ------------------------------------------------------------
+
+        # change template to a one with mails -> fill event as it is void
         event_type.write({
             'use_mail_schedule': True,
             'event_type_mail_ids': [(5, 0), (0, 0, {
                 'interval_nbr': 1, 'interval_unit': 'days', 'interval_type': 'before_event',
-                'template_id': self.env['ir.model.data'].xmlid_to_res_id('event.event_reminder')})]
+                'template_id': self.env['ir.model.data'].xmlid_to_res_id('event.event_reminder')})],
+            'use_ticket': True,
+            'event_type_ticket_ids': [(5, 0), (0, 0, {'name': 'TestRegistration'})],
         })
         event.write({'event_type_id': event_type.id})
         self.assertEqual(event.date_tz, 'Europe/Paris')
         self.assertTrue(event.seats_limited)
         self.assertEqual(event.seats_max, event_type.seats_max)
         self.assertTrue(event.auto_confirm)
+        # check 2many fields being populated
+        self.assertEqual(len(event.event_mail_ids), 1)
         self.assertEqual(event.event_mail_ids.interval_nbr, 1)
         self.assertEqual(event.event_mail_ids.interval_unit, 'days')
         self.assertEqual(event.event_mail_ids.interval_type, 'before_event')
         self.assertEqual(event.event_mail_ids.template_id, self.env.ref('event.event_reminder'))
+        self.assertEqual(len(event.event_ticket_ids), 1)
+        event_ticket1 = event.event_ticket_ids[0]
+        self.assertEqual(event_ticket1.name, 'TestRegistration')
+
+        # ------------------------------------------------------------
+        # RESET TEST
+        # ------------------------------------------------------------
+
+        # link registration to ticket
+        registration.write({'event_ticket_id': event_ticket1.id})
+        self.assertEqual(registration.event_ticket_id, event_ticket1)
+
+        # change template to a void one for mails -> do not reset event
+        # change template to a one with other tickets -> reset event
+        event_type.write({
+            'use_mail_schedule': False,
+            'event_type_mail_ids': [(5, 0)],
+            'event_type_ticket_ids': [(5, 0),
+                                      (0, 0, {'name': 'Registration1'}),
+                                      (0, 0, {'name': 'Registration2'})],
+        })
+        event._compute_from_event_type()
+        self.assertEqual(len(event.event_mail_ids), 1)
+        self.assertEqual(len(event.event_ticket_ids), 2)
+        self.assertEqual(
+            set(event.mapped('event_ticket_ids.name')),
+            set(['Registration1', 'Registration2'])
+        )
+        # registration loose its ticket
+        self.assertEqual(registration.event_ticket_id, self.env['event.event.ticket'])
+
+        # change template to a one with different mails -> reset event
+        event_type.write({
+            'use_mail_schedule': True,
+            'event_type_mail_ids': [(5, 0), (0, 0, {
+                'interval_nbr': 3, 'interval_unit': 'days', 'interval_type': 'after_event',
+                'template_id': self.env['ir.model.data'].xmlid_to_res_id('event.event_reminder')})]
+        })
+        event._compute_from_event_type()
+        self.assertEqual(len(event.event_mail_ids), 1)
+        self.assertEqual(event.event_mail_ids.interval_nbr, 3)
+        self.assertEqual(event.event_mail_ids.interval_type, 'after_event')
 
     @users('user_eventmanager')
     def test_event_registrable(self):
@@ -235,6 +252,49 @@ class TestEventData(TestEventCommon):
         finished_or_upcoming_event_ids = self.env['event.event']._search([('is_ongoing', '=', False)])
         self.assertNotIn(event_2.id, finished_or_upcoming_event_ids)
 
+    @users('user_eventmanager')
+    def test_event_seats(self):
+        event_type = self.event_type_complex.with_user(self.env.user)
+        event = self.env['event.event'].create({
+            'name': 'Event Update Type',
+            'event_type_id': event_type.id,
+            'date_begin': FieldsDatetime.to_string(datetime.today() + timedelta(days=1)),
+            'date_end': FieldsDatetime.to_string(datetime.today() + timedelta(days=15)),
+        })
+
+        self.assertEqual(event.address_id, self.env.user.company_id.partner_id)
+        # seats: coming from event type configuration
+        self.assertTrue(event.seats_limited)
+        self.assertEqual(event.seats_available, event.event_type_id.seats_max)
+        self.assertEqual(event.seats_unconfirmed, 0)
+        self.assertEqual(event.seats_reserved, 0)
+        self.assertEqual(event.seats_used, 0)
+        self.assertEqual(event.seats_expected, 0)
+
+        # create registration in order to check the seats computation
+        self.assertTrue(event.auto_confirm)
+        for x in range(5):
+            reg = self.env['event.registration'].create({
+                'event_id': event.id,
+                'name': 'reg_open',
+            })
+            self.assertEqual(reg.state, 'open')
+        reg_draft = self.env['event.registration'].create({
+            'event_id': event.id,
+            'name': 'reg_draft',
+        })
+        reg_draft.write({'state': 'draft'})
+        reg_done = self.env['event.registration'].create({
+            'event_id': event.id,
+            'name': 'reg_done',
+        })
+        reg_done.write({'state': 'done'})
+        self.assertEqual(event.seats_available, event.event_type_id.seats_max - 6)
+        self.assertEqual(event.seats_unconfirmed, 1)
+        self.assertEqual(event.seats_reserved, 5)
+        self.assertEqual(event.seats_used, 1)
+        self.assertEqual(event.seats_expected, 7)
+
 
 class TestEventTicketData(TestEventCommon):