initial commit 2

3 files changed, 293 insertions, 0 deletions

diff --git a/addons/event_crm/tests/__init__.py b/addons/event_crm/tests/__init__.py
new file mode 100644
index 00000000..4d35e728
--- /dev/null
+++ b/addons/event_crm/tests/__init__.py
@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from . import test_event_crm_flow
diff --git a/addons/event_crm/tests/common.py b/addons/event_crm/tests/common.py
new file mode 100644
index 00000000..c27b82d2
--- /dev/null
+++ b/addons/event_crm/tests/common.py
@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.addons.crm.tests.common import TestCrmCommon
+from odoo.addons.event.tests.common import TestEventCommon
+
+
+class TestEventCrmCommon(TestCrmCommon, TestEventCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestEventCrmCommon, cls).setUpClass()
+
+        # avoid clash with existing rules
+        cls.env['event.lead.rule'].search([]).write({'active': False})
+
+        cls.test_lead_tag = cls.env['crm.tag'].create({'name': 'TagTest'})
+
+        cls.test_rule_attendee = cls.env['event.lead.rule'].create({
+            'name': 'Rule Attendee',
+            'lead_creation_basis': 'attendee',
+            'lead_creation_trigger': 'create',
+            'event_id': cls.event_0.id,
+            'event_registration_filter': [['email', 'ilike', '@test.example.com']],
+            'lead_type': 'lead',
+            'lead_user_id': cls.user_sales_salesman.id,
+            'lead_tag_ids': cls.test_lead_tag,
+        })
+
+        cls.test_rule_order = cls.env['event.lead.rule'].create({
+            'name': 'Rule Order',
+            'lead_creation_basis': 'order',
+            'lead_creation_trigger': 'create',
+            'event_id': cls.event_0.id,
+            'event_registration_filter': [['email', 'ilike', '@test.example.com']],
+            'lead_type': 'opportunity',
+            'lead_user_id': cls.user_sales_leads.id,
+            'lead_sales_team_id': cls.sales_team_1.id,
+        })
+        cls.test_rule_order_done = cls.env['event.lead.rule'].create({
+            'name': 'Rule Order: confirmed partner only',
+            'lead_creation_basis': 'order',
+            'lead_creation_trigger': 'done',
+            'event_registration_filter': [['partner_id', '!=', False]],
+            'lead_type': 'opportunity',
+        })
+
+        cls.batch_customer_data = [{
+            'partner_id': cls.event_customer.id,
+        }] + [{
+            'name': 'My Customer 00',
+            'partner_id': cls.event_customer2.id,
+            'email': 'email.00@test.example.com',
+            'phone': '0456000000',
+        }] + [{
+            'name': 'My Customer %02d' % x,
+            'partner_id': cls.env.ref('base.public_partner').id if x == 0 else False,
+            'email': 'email.%02d@test.example.com' % x,
+            'phone': '04560000%02d' % x,
+        }  for x in range(1, 4)]
+
+    def assertLeadConvertion(self, rule, registrations, partner=None, **expected):
+        """ Tool method hiding details of lead value generation and check
+
+        :param lead: lead created through automated rule;
+        :param rule: event.lead.rule that created the lead;
+        :param event: original event;
+        :param registrations: source registrations (singleton or record set if done in batch);
+        :param partner: partner on lead;
+        """
+        registrations = registrations.sorted('id')  # currently order is forced to id ASC
+        lead = self.env['crm.lead'].sudo().search([
+            ('registration_ids', 'in', registrations.ids),
+            ('event_lead_rule_id', '=', rule.id)
+        ])
+        self.assertEqual(len(lead), 1, 'Invalid registrations -> lead creation, found %s leads where only 1 is expected.' % len(lead))
+        self.assertEqual(lead.registration_ids, registrations, 'Invalid registrations -> lead creation, too much registrations on it.')
+        event = registrations.event_id
+        self.assertEqual(len(event), 1, 'Invalid registrations -> event assertion, all registrations should belong to same event')
+
+        if partner is None:
+            partner = self.env['res.partner']
+        expected_reg_name = partner.name or registrations._find_first_notnull('name') or registrations._find_first_notnull('email')
+        if partner:
+            expected_contact_name = partner.name if not partner.is_company else False
+            expected_partner_name = partner.name if partner.is_company else False
+        else:
+            expected_contact_name = registrations._find_first_notnull('name')
+            expected_partner_name = False
+
+        # event information
+        self.assertEqual(lead.event_id, event)
+        self.assertEqual(lead.referred, event.name)
+
+        # registration information
+        self.assertEqual(lead.partner_id, partner)
+        self.assertEqual(lead.name, '%s - %s' % (event.name, expected_reg_name))
+        self.assertNotIn('False', lead.name)  # avoid a "Dear False" like construct ^^ (this assert is serious and intended)
+
+        self.assertEqual(lead.contact_name, expected_contact_name)
+        self.assertEqual(lead.partner_name, expected_partner_name)
+        self.assertEqual(lead.email_from, partner.email if partner else registrations._find_first_notnull('email'))
+        self.assertEqual(lead.phone, partner.phone if partner else registrations._find_first_notnull('phone'))
+        self.assertEqual(lead.mobile, partner.mobile if partner and partner.mobile else registrations._find_first_notnull('mobile'))
+
+        # description: to improve
+        self.assertNotIn('False', lead.description)  # avoid a "Dear False" like construct ^^ (this assert is serious and intended)
+        for registration in registrations:
+            if registration.name:
+                self.assertIn(registration.name, lead.description)
+            elif registration.partner_id.name:
+                self.assertIn(registration.partner_id.name, lead.description)
+            if registration.email:
+                self.assertIn(registration.email, lead.description)
+            if registration.phone:
+                self.assertIn(registration.phone, lead.description)
+
+        # lead configuration
+        self.assertEqual(lead.type, rule.lead_type)
+        self.assertEqual(lead.user_id, rule.lead_user_id)
+        self.assertEqual(lead.team_id, rule.lead_sales_team_id)
+        self.assertEqual(lead.tag_ids, rule.lead_tag_ids)
diff --git a/addons/event_crm/tests/test_event_crm_flow.py b/addons/event_crm/tests/test_event_crm_flow.py
new file mode 100644
index 00000000..effee957
--- /dev/null
+++ b/addons/event_crm/tests/test_event_crm_flow.py
@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.addons.event_crm.tests.common import TestEventCrmCommon
+from odoo.tests.common import users
+from odoo.tools import mute_logger
+
+
+class TestEventCrmFlow(TestEventCrmCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestEventCrmFlow, cls).setUpClass()
+
+        cls.registration_values = [
+            dict(customer_data, event_id=cls.event_0.id)
+            for customer_data in cls.batch_customer_data
+        ]
+        cls.registration_values[-1]['email'] = '"John Doe" <invalid@not.example.com>'
+
+    def assert_initial_data(self):
+        self.assertEqual(len(self.registration_values), 5)
+        self.assertEqual(self.event_customer.email_normalized, 'constantin@test.example.com')
+        self.assertEqual(self.event_customer.phone, '0485112233')
+        self.assertFalse(self.event_customer.mobile)
+
+    @users('user_eventmanager')
+    def test_event_crm_flow_batch_create(self):
+        """ Test attendee- and order-based registrations creation. Event-based
+        creation mimics a simplified website_event flow where grouping is done
+        at create. """
+        new_registrations = self.env['event.registration'].create(self.registration_values)
+        self.assertEqual(len(self.event_0.registration_ids), 5)
+
+        # per-attendee rule: one lead for each registration
+        self.assertEqual(len(self.test_rule_attendee.lead_ids), 4)
+        for registration in new_registrations:
+            lead = self.test_rule_attendee.lead_ids.filtered(lambda lead: registration in lead.registration_ids)
+            # test filtering out based on domain
+            if registration.email == '"John Doe" <invalid@not.example.com>':
+                self.assertEqual(lead, self.env['crm.lead'])
+                continue
+
+            # only partner with matching email / phone is kept in mono attendee mode to avoid
+            # loosing registration-specific email / phone informations due to lead synchronization
+            expected_partner = registration.partner_id if registration.partner_id == self.event_customer else None
+            self.assertTrue(bool(lead))
+            self.assertLeadConvertion(self.test_rule_attendee, registration, partner=expected_partner)
+
+        # per-order rule: one lead for all registrations (same event -> same batch, website_event style)
+        self.assertEqual(len(self.test_rule_order.lead_ids), 1)
+        lead = self.test_rule_order.lead_ids
+        self.assertLeadConvertion(
+            self.test_rule_order,
+            new_registrations.filtered(lambda reg: reg.email != '"John Doe" <invalid@not.example.com>'),
+            partner=new_registrations[0].partner_id
+        )
+        # ensuring filtering out worked also at description level
+        self.assertNotIn('invalid@not.example.com', lead.description)
+
+    @users('user_eventmanager')
+    def test_event_crm_flow_batch_update(self):
+        """ Test update of contact or description fields that leads to lead
+        update. """
+        # initial data: create registrations in batch
+        new_registrations = self.env['event.registration'].create(self.registration_values)
+        self.assertEqual(len(self.event_0.registration_ids), 5)
+        self.assertEqual(len(self.test_rule_attendee.lead_ids), 4)
+        self.assertEqual(len(self.test_rule_order.lead_ids), 1)
+
+        # customer is updated (like a SO setting its customer)
+        new_registrations.write({'partner_id': self.event_customer2.id})
+
+        # per-attendee rule
+        self.assertEqual(len(self.test_rule_attendee.lead_ids), 4)
+        for registration in new_registrations:
+            lead = self.test_rule_attendee.lead_ids.filtered(lambda lead: registration in lead.registration_ids)
+            # test filtering out based on domain
+            if registration.email == '"John Doe" <invalid@not.example.com>':
+                self.assertEqual(lead, self.env['crm.lead'])
+                continue
+
+            # only partner with matching email / phone is kept in mono attendee mode to avoid
+            # loosing registration-specific email / phone informations due to lead synchronization
+            self.assertLeadConvertion(self.test_rule_attendee, registration, partner=None)
+
+        # per-order rule
+        self.assertEqual(len(self.test_rule_order.lead_ids), 1)
+        self.assertEqual(self.test_rule_order.lead_ids.event_id, self.event_0)
+        lead = self.test_rule_order.lead_ids
+        self.assertLeadConvertion(
+            self.test_rule_order,
+            new_registrations.filtered(lambda reg: reg.email != '"John Doe" <invalid@not.example.com>'),
+            partner=new_registrations[0].partner_id
+        )
+        # ensuring filtering out worked also at description level
+        self.assertNotIn('invalid@not.example.com', lead.description)
+
+    @users('user_eventmanager')
+    def test_event_crm_flow_per_attendee_single(self):
+        self.assert_initial_data()
+
+        # test: partner-based contact information, everything synchonized
+        registration = self.env['event.registration'].create({
+            'partner_id': self.event_customer.id,
+            'event_id': self.event_0.id,
+        })
+        self.assertEqual(registration.email, self.event_customer.email)
+        self.assertEqual(registration.phone, self.event_customer.phone)
+
+        # per-attendee rule
+        self.assertLeadConvertion(self.test_rule_attendee, registration, partner=registration.partner_id)
+
+        # test: no partner and contact information
+        registration = self.env['event.registration'].create({
+            'name': 'My Registration',
+            'partner_id': False,
+            'email': 'super.email@test.example.com',
+            'phone': False,
+            'mobile': '0456332211',
+            'event_id': self.event_0.id,
+        })
+        self.assertEqual(len(self.event_0.registration_ids), 2)
+        self.assertLeadConvertion(self.test_rule_attendee, registration, partner=None)
+
+        # test: no partner and few information
+        registration = self.env['event.registration'].create({
+            'name': False,
+            'partner_id': False,
+            'email': 'giga.email@test.example.com',
+            'phone': False,
+            'mobile': False,
+            'event_id': self.event_0.id,
+        })
+        self.assertEqual(len(self.event_0.registration_ids), 3)
+        self.assertLeadConvertion(self.test_rule_attendee, registration, partner=None)
+
+        # test: partner but with other contact information -> registration prior
+        registration = self.env['event.registration'].create({
+            'partner_id': self.event_customer.id,
+            'email': 'other.email@test.example.com',
+            'phone': False,
+            'mobile': '0456112233',
+            'event_id': self.event_0.id,
+        })
+        self.assertEqual(len(self.event_0.registration_ids), 4)
+        self.assertLeadConvertion(self.test_rule_attendee, registration, partner=None)
+
+    @users('user_eventmanager')
+    def test_order_rule_duplicate_lead(self):
+        """ Check when two rules match one event
+            but only one match the registration,
+            only one lead should be created
+        """
+        test_rule_order_2 = self.test_rule_order.copy(default={
+            'event_registration_filter': [['email', 'not ilike', '@test.example.com']]
+        })
+        self.env['event.registration'].create({
+            'name': 'My Registration',
+            'partner_id': False,
+            'email': 'super.email@test.example.com',
+            'phone': False,
+            'mobile': '0456332211',
+            'event_id': self.event_0.id,
+        })
+        self.assertEqual(len(self.test_rule_order.lead_ids), 1)
+        self.assertEqual(len(test_rule_order_2.lead_ids), 0)