mirror of
https://github.com/bringout/oca-ocb-test.git
synced 2026-04-24 13:22:04 +02:00
Initial commit: Test packages
This commit is contained in:
Ernad Husremovic
commit
080accd21c
338 changed files with 32413 additions and 0 deletions
|
|
@ -0,0 +1,11 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from . import common
|
||||
from . import test_event_crm
|
||||
from . import test_event_event
|
||||
from . import test_event_mail
|
||||
from . import test_event_security
|
||||
from . import test_performance
|
||||
from . import test_wevent_register
|
||||
from . import test_event_discount
|
||||
|
|
@ -0,0 +1,462 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from datetime import datetime, timedelta, time
|
||||
|
||||
from odoo.addons.base.tests.common import HttpCaseWithUserDemo, HttpCaseWithUserPortal
|
||||
from odoo.addons.event_crm.tests.common import EventCrmCase
|
||||
from odoo.addons.mail.tests.common import mail_new_test_user
|
||||
from odoo.addons.sales_team.tests.common import TestSalesCommon
|
||||
from odoo.addons.website.tests.test_website_visitor import MockVisitor
|
||||
|
||||
|
||||
class TestEventFullCommon(EventCrmCase, TestSalesCommon, MockVisitor):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
super(TestEventFullCommon, cls).setUpClass()
|
||||
cls._init_mail_gateway()
|
||||
|
||||
# Context data: dates
|
||||
# ------------------------------------------------------------
|
||||
|
||||
# Mock dates to have reproducible computed fields based on time
|
||||
cls.reference_now = datetime(2021, 12, 1, 10, 0, 0)
|
||||
cls.reference_today = datetime(2021, 12, 1)
|
||||
|
||||
# Users and contacts
|
||||
# ------------------------------------------------------------
|
||||
|
||||
cls.admin_user = cls.env.ref('base.user_admin')
|
||||
cls.admin_user.write({
|
||||
'country_id': cls.env.ref('base.be').id,
|
||||
'login': 'admin',
|
||||
'notification_type': 'inbox',
|
||||
})
|
||||
cls.company_admin = cls.admin_user.company_id
|
||||
# set country in order to format Belgian numbers
|
||||
cls.company_admin.write({
|
||||
'country_id': cls.env.ref('base.be').id,
|
||||
})
|
||||
cls.event_user = mail_new_test_user(
|
||||
cls.env,
|
||||
company_id=cls.company_admin.id,
|
||||
company_ids=[(4, cls.company_admin.id)],
|
||||
country_id=cls.env.ref('base.be').id,
|
||||
groups='base.group_user,base.group_partner_manager,event.group_event_user',
|
||||
email='e.e@example.com',
|
||||
login='event_user',
|
||||
name='Ernest Employee',
|
||||
notification_type='inbox',
|
||||
signature='--\nErnest',
|
||||
)
|
||||
|
||||
cls.customer = cls.env['res.partner'].create({
|
||||
'country_id': cls.env.ref('base.be').id,
|
||||
'email': 'customer.test@example.com',
|
||||
'name': 'Test Customer',
|
||||
'mobile': '0456123456',
|
||||
'phone': '0456123456',
|
||||
})
|
||||
# make a SO for a customer, selling some tickets
|
||||
cls.customer_so = cls.env['sale.order'].with_user(cls.user_sales_salesman).create({
|
||||
'partner_id': cls.event_customer.id,
|
||||
})
|
||||
|
||||
# Side records for event main records
|
||||
# ------------------------------------------------------------
|
||||
|
||||
cls.ticket_product = cls.env['product.product'].create({
|
||||
'description_sale': 'Ticket Product Description',
|
||||
'detailed_type': 'event',
|
||||
'list_price': 10,
|
||||
'name': 'Test Registration Product',
|
||||
'standard_price': 30.0,
|
||||
})
|
||||
cls.booth_product = cls.env['product.product'].create({
|
||||
'description_sale': 'Booth Product Description',
|
||||
'detailed_type': 'event_booth',
|
||||
'list_price': 20,
|
||||
'name': 'Test Booth Product',
|
||||
'standard_price': 60.0,
|
||||
})
|
||||
|
||||
cls.tag_categories = cls.env['event.tag.category'].create([
|
||||
{'is_published': True, 'name': 'Published Category'},
|
||||
{'is_published': False, 'name': 'Unpublished Category'},
|
||||
])
|
||||
cls.tags = cls.env['event.tag'].create([
|
||||
{'category_id': cls.tag_categories[0].id, 'name': 'PubTag1'},
|
||||
{'category_id': cls.tag_categories[0].id, 'color': 0, 'name': 'PubTag2'},
|
||||
{'category_id': cls.tag_categories[1].id, 'name': 'UnpubTag1'},
|
||||
])
|
||||
|
||||
cls.event_booth_categories = cls.env['event.booth.category'].create([
|
||||
{'description': '<p>Standard</p>',
|
||||
'name': 'Standard',
|
||||
'product_id': cls.booth_product.id,
|
||||
},
|
||||
{'description': '<p>Premium</p>',
|
||||
'name': 'Premium',
|
||||
'product_id': cls.booth_product.id,
|
||||
'price': 90,
|
||||
}
|
||||
])
|
||||
|
||||
cls.sponsor_types = cls.env['event.sponsor.type'].create([
|
||||
{'name': 'GigaTop',
|
||||
'sequence': 1,
|
||||
}
|
||||
])
|
||||
cls.sponsor_partners = cls.env['res.partner'].create([
|
||||
{'country_id': cls.env.ref('base.be').id,
|
||||
'email': 'event.sponsor@example.com',
|
||||
'name': 'EventSponsor',
|
||||
'phone': '04856112233',
|
||||
}
|
||||
])
|
||||
|
||||
# Event type
|
||||
# ------------------------------------------------------------
|
||||
test_registration_report = cls.env.ref('test_event_full.event_registration_report_test')
|
||||
subscription_template = cls.env.ref('event.event_subscription')
|
||||
subscription_template.write({'report_template': test_registration_report.id})
|
||||
cls.test_event_type = cls.env['event.type'].create({
|
||||
'auto_confirm': True,
|
||||
'default_timezone': 'Europe/Paris',
|
||||
'event_type_booth_ids': [
|
||||
(0, 0, {'booth_category_id': cls.event_booth_categories[0].id,
|
||||
'name': 'Standard Booth',
|
||||
}
|
||||
),
|
||||
(0, 0, {'booth_category_id': cls.event_booth_categories[0].id,
|
||||
'name': 'Standard Booth 2',
|
||||
}
|
||||
),
|
||||
(0, 0, {'booth_category_id': cls.event_booth_categories[1].id,
|
||||
'name': 'Premium Booth',
|
||||
}
|
||||
),
|
||||
(0, 0, {'booth_category_id': cls.event_booth_categories[1].id,
|
||||
'name': 'Premium Booth 2',
|
||||
}
|
||||
),
|
||||
],
|
||||
'event_type_mail_ids': [
|
||||
(0, 0, {'interval_unit': 'now', # right at subscription
|
||||
'interval_type': 'after_sub',
|
||||
'notification_type': 'mail',
|
||||
'template_ref': 'mail.template,%i' % subscription_template.id,
|
||||
}
|
||||
),
|
||||
(0, 0, {'interval_nbr': 1, # 1 days before event
|
||||
'interval_unit': 'days',
|
||||
'interval_type': 'before_event',
|
||||
'notification_type': 'mail',
|
||||
'template_ref': 'mail.template,%i' % cls.env['ir.model.data']._xmlid_to_res_id('event.event_reminder'),
|
||||
}
|
||||
),
|
||||
(0, 0, {'interval_nbr': 1, # 1 days after event
|
||||
'interval_unit': 'days',
|
||||
'interval_type': 'after_event',
|
||||
'notification_type': 'sms',
|
||||
'template_ref': 'sms.template,%i' % cls.env['ir.model.data']._xmlid_to_res_id('event_sms.sms_template_data_event_reminder'),
|
||||
}
|
||||
),
|
||||
],
|
||||
'event_type_ticket_ids': [
|
||||
(0, 0, {'description': 'Ticket1 Description',
|
||||
'name': 'Ticket1',
|
||||
'product_id': cls.ticket_product.id,
|
||||
'seats_max': 10,
|
||||
}
|
||||
),
|
||||
(0, 0, {'description': 'Ticket2 Description',
|
||||
'name': 'Ticket2',
|
||||
'product_id': cls.ticket_product.id,
|
||||
'price': 45,
|
||||
}
|
||||
)
|
||||
],
|
||||
'has_seats_limitation': True,
|
||||
'name': 'Test Type',
|
||||
'note': '<p>Template note</p>',
|
||||
'question_ids': [
|
||||
(0, 0, {'answer_ids':
|
||||
[(0, 0, {'name': 'Q1-Answer1'}),
|
||||
(0, 0, {'name': 'Q1-Answer2'}),
|
||||
],
|
||||
'question_type': 'simple_choice',
|
||||
'once_per_order': False,
|
||||
'title': 'Question1',
|
||||
}
|
||||
),
|
||||
(0, 0, {'answer_ids':
|
||||
[(0, 0, {'name': 'Q2-Answer1'}),
|
||||
(0, 0, {'name': 'Q2-Answer2'}),
|
||||
],
|
||||
'question_type': 'simple_choice',
|
||||
'once_per_order': False,
|
||||
'title': 'Question2',
|
||||
}
|
||||
),
|
||||
(0, 0, {'question_type': 'text_box',
|
||||
'once_per_order': True,
|
||||
'title': 'Question3',
|
||||
}
|
||||
),
|
||||
],
|
||||
'seats_max': 30,
|
||||
'tag_ids': [(4, tag.id) for tag in cls.tags],
|
||||
'ticket_instructions': '<p>Ticket Instructions</p>',
|
||||
'website_menu': True,
|
||||
})
|
||||
|
||||
# Stages
|
||||
cls.stage_def = cls.env['event.stage'].create({
|
||||
'name': 'First Stage',
|
||||
'sequence': 0,
|
||||
})
|
||||
|
||||
# Event data
|
||||
# ------------------------------------------------------------
|
||||
|
||||
cls.event_base_vals = {
|
||||
'name': 'Test Event',
|
||||
'date_begin': cls.reference_now + timedelta(days=1),
|
||||
'date_end': cls.reference_now + timedelta(days=5),
|
||||
'is_published': True,
|
||||
}
|
||||
|
||||
cls.test_event = cls.env['event.event'].create({
|
||||
'name': 'Test Event',
|
||||
'auto_confirm': True,
|
||||
'date_begin': datetime.now() + timedelta(days=1),
|
||||
'date_end': datetime.now() + timedelta(days=5),
|
||||
'date_tz': 'Europe/Brussels',
|
||||
'event_type_id': cls.test_event_type.id,
|
||||
'is_published': True,
|
||||
})
|
||||
# update post-synchronize data
|
||||
ticket_1 = cls.test_event.event_ticket_ids.filtered(lambda t: t.name == 'Ticket1')
|
||||
ticket_2 = cls.test_event.event_ticket_ids.filtered(lambda t: t.name == 'Ticket2')
|
||||
ticket_1.start_sale_datetime = cls.reference_now + timedelta(hours=1)
|
||||
ticket_2.start_sale_datetime = cls.reference_now + timedelta(hours=2)
|
||||
|
||||
# Website data
|
||||
# ------------------------------------------------------------
|
||||
|
||||
cls.website = cls.env['website'].search([
|
||||
('company_id', '=', cls.company_admin.id)
|
||||
], limit=1)
|
||||
|
||||
cls.customer_data = [
|
||||
{'email': 'customer.email.%02d@test.example.com' % x,
|
||||
'name': 'My Customer %02d' % x,
|
||||
'mobile': '04569999%02d' % x,
|
||||
'partner_id': False,
|
||||
'phone': '04560000%02d' % x,
|
||||
} for x in range(0, 10)
|
||||
]
|
||||
cls.website_customer_data = [
|
||||
{'email': 'website.email.%02d@test.example.com' % x,
|
||||
'name': 'My Customer %02d' % x,
|
||||
'mobile': '04569999%02d' % x,
|
||||
'partner_id': cls.env.ref('base.public_partner').id,
|
||||
'phone': '04560000%02d' % x,
|
||||
'registration_answer_ids': [
|
||||
(0, 0, {
|
||||
'question_id': cls.test_event.question_ids[0].id,
|
||||
'value_answer_id': cls.test_event.question_ids[0].answer_ids[(x % 2)].id,
|
||||
}), (0, 0, {
|
||||
'question_id': cls.test_event.question_ids[1].id,
|
||||
'value_answer_id': cls.test_event.question_ids[1].answer_ids[(x % 2)].id,
|
||||
}), (0, 0, {
|
||||
'question_id': cls.test_event.question_ids[2].id,
|
||||
'value_text_box': 'CustomerAnswer%s' % x,
|
||||
})
|
||||
],
|
||||
} for x in range(0, 10)
|
||||
]
|
||||
cls.partners = cls.env['res.partner'].create([
|
||||
{'email': 'partner.email.%02d@test.example.com' % x,
|
||||
'name': 'PartnerCustomer',
|
||||
'mobile': '04569999%02d' % x,
|
||||
'phone': '04560000%02d' % x,
|
||||
} for x in range(0, 10)
|
||||
])
|
||||
|
||||
def assertLeadConvertion(self, rule, registrations, partner=None, **expected):
|
||||
super(TestEventFullCommon, self).assertLeadConvertion(rule, registrations, partner=partner, **expected)
|
||||
lead = self.env['crm.lead'].sudo().search([
|
||||
('registration_ids', 'in', registrations.ids),
|
||||
('event_lead_rule_id', '=', rule.id)
|
||||
])
|
||||
|
||||
for registration in registrations:
|
||||
if not registration.registration_answer_ids:
|
||||
continue
|
||||
for answer in registration.registration_answer_ids:
|
||||
self.assertIn(answer.question_id.title, lead.description)
|
||||
if answer.question_type == 'simple_choice':
|
||||
self.assertIn(answer.value_answer_id.name, lead.description)
|
||||
else:
|
||||
self.assertIn(answer.value_text_box, lead.description) # better: check multi line
|
||||
|
||||
|
||||
class TestWEventCommon(HttpCaseWithUserDemo, HttpCaseWithUserPortal, MockVisitor):
|
||||
|
||||
def setUp(self):
|
||||
super(TestWEventCommon, self).setUp()
|
||||
|
||||
# Context data: dates
|
||||
# ------------------------------------------------------------
|
||||
|
||||
# Mock dates to have reproducible computed fields based on time
|
||||
self.reference_now = datetime(2021, 12, 1, 10, 0, 0)
|
||||
self.reference_today = datetime(2021, 12, 1)
|
||||
|
||||
self.event_product = self.env['product.product'].create({
|
||||
'name': 'Test Event Registration',
|
||||
'default_code': 'EVENT_REG',
|
||||
'description_sale': 'Mighty Description',
|
||||
'list_price': 10,
|
||||
'standard_price': 30.0,
|
||||
'detailed_type': 'event',
|
||||
})
|
||||
|
||||
self.event_tag_category_1 = self.env['event.tag.category'].create({
|
||||
'name': 'Type',
|
||||
'sequence': 2,
|
||||
})
|
||||
self.event_tag_category_1_tag_1 = self.env['event.tag'].create({
|
||||
'name': 'Online',
|
||||
'sequence': 10,
|
||||
'category_id': self.event_tag_category_1.id,
|
||||
'color': 8,
|
||||
})
|
||||
self.env['event.event'].search(
|
||||
[('name', 'like', '%Online Reveal%')]
|
||||
).write(
|
||||
{'name': 'Do not click on me'}
|
||||
)
|
||||
self.event = self.env['event.event'].create({
|
||||
'name': 'Online Reveal TestEvent',
|
||||
'auto_confirm': True,
|
||||
'stage_id': self.env.ref('event.event_stage_booked').id,
|
||||
'address_id': False,
|
||||
'user_id': self.user_demo.id,
|
||||
'tag_ids': [(4, self.event_tag_category_1_tag_1.id)],
|
||||
# event if 8-18 in Europe/Brussels (DST) (first day: begins at 7, last day: ends at 17)
|
||||
'date_tz': 'Europe/Brussels',
|
||||
'date_begin': datetime.combine(self.reference_now, time(5, 0)) - timedelta(days=1),
|
||||
'date_end': datetime.combine(self.reference_now, time(15, 0)) + timedelta(days=1),
|
||||
# ticket informations
|
||||
'event_ticket_ids': [
|
||||
(0, 0, {
|
||||
'name': 'Standard',
|
||||
'product_id': self.event_product.id,
|
||||
'price': 0,
|
||||
}), (0, 0, {
|
||||
'name': 'VIP',
|
||||
'product_id': self.event_product.id,
|
||||
'seats_max': 10,
|
||||
})
|
||||
],
|
||||
# activate menus
|
||||
'is_published': True,
|
||||
'website_menu': True,
|
||||
'website_track': True,
|
||||
'website_track_proposal': True,
|
||||
'exhibitor_menu': True,
|
||||
'community_menu': True,
|
||||
})
|
||||
|
||||
self.event_customer = self.env['res.partner'].create({
|
||||
'name': 'Constantin Customer',
|
||||
'email': 'constantin@test.example.com',
|
||||
'country_id': self.env.ref('base.be').id,
|
||||
'phone': '0485112233',
|
||||
'mobile': False,
|
||||
})
|
||||
self.event_speaker = self.env['res.partner'].create({
|
||||
'name': 'Brandon Freeman',
|
||||
'email': 'brandon.freeman55@example.com',
|
||||
'phone': '(355)-687-3262',
|
||||
})
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# QUESTIONS
|
||||
# ------------------------------------------------------------
|
||||
|
||||
self.event_question_1 = self.env['event.question'].create({
|
||||
'title': 'Which field are you working in',
|
||||
'question_type': 'simple_choice',
|
||||
'event_id': self.event.id,
|
||||
'once_per_order': False,
|
||||
'answer_ids': [
|
||||
(0, 0, {'name': 'Consumers'}),
|
||||
(0, 0, {'name': 'Sales'}),
|
||||
(0, 0, {'name': 'Research'}),
|
||||
],
|
||||
})
|
||||
self.event_question_2 = self.env['event.question'].create({
|
||||
'title': 'How did you hear about us ?',
|
||||
'question_type': 'text_box',
|
||||
'event_id': self.event.id,
|
||||
'once_per_order': True,
|
||||
})
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# TRACKS
|
||||
# ------------------------------------------------------------
|
||||
|
||||
self.track_0 = self.env['event.track'].create({
|
||||
'name': 'What This Event Is All About',
|
||||
'event_id': self.event.id,
|
||||
'stage_id': self.env.ref('website_event_track.event_track_stage3').id,
|
||||
'date': self.reference_now + timedelta(hours=1),
|
||||
'duration': 2,
|
||||
'is_published': True,
|
||||
'wishlisted_by_default': True,
|
||||
'user_id': self.user_admin.id,
|
||||
'partner_id': self.event_speaker.id,
|
||||
})
|
||||
self.track_1 = self.env['event.track'].create({
|
||||
'name': 'Live Testimonial',
|
||||
'event_id': self.event.id,
|
||||
'stage_id': self.env.ref('website_event_track.event_track_stage3').id,
|
||||
'date': self.reference_now - timedelta(minutes=30),
|
||||
'duration': 0.75,
|
||||
'is_published': True,
|
||||
'user_id': self.user_admin.id,
|
||||
'partner_id': self.event_speaker.id,
|
||||
})
|
||||
self.track_2 = self.env['event.track'].create({
|
||||
'name': 'Our Last Day Together !',
|
||||
'event_id': self.event.id,
|
||||
'stage_id': self.env.ref('website_event_track.event_track_stage3').id,
|
||||
'date': self.reference_now + timedelta(days=1),
|
||||
'duration': 0.75,
|
||||
'is_published': True,
|
||||
'user_id': self.user_admin.id,
|
||||
'partner_id': self.event_speaker.id,
|
||||
})
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# MEETING ROOMS
|
||||
# ----------------------------------------------------------
|
||||
|
||||
self.env['event.meeting.room'].create({
|
||||
'name': 'Best wood for furniture',
|
||||
'summary': 'Let\'s talk about wood types for furniture',
|
||||
'target_audience': 'wood expert(s)',
|
||||
'is_pinned': True,
|
||||
'website_published': True,
|
||||
'event_id': self.event.id,
|
||||
'room_lang_id': self.env.ref('base.lang_en').id,
|
||||
'room_max_capacity': '12',
|
||||
'room_participant_count': 9,
|
||||
})
|
||||
|
||||
self.env.flush_all()
|
||||
|
|
@ -0,0 +1,177 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from odoo.addons.test_event_full.tests.common import TestEventFullCommon
|
||||
from odoo.tests import users
|
||||
|
||||
|
||||
class TestEventCrm(TestEventFullCommon):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
super(TestEventCrm, cls).setUpClass()
|
||||
|
||||
cls.TICKET1_COUNT, cls.TICKET2_COUNT = 3, 1
|
||||
ticket1 = cls.test_event.event_ticket_ids[0]
|
||||
ticket2 = cls.test_event.event_ticket_ids[1]
|
||||
|
||||
(cls.test_rule_attendee + cls.test_rule_order).write({'event_id': cls.test_event.id})
|
||||
|
||||
# PREPARE SO DATA
|
||||
# ------------------------------------------------------------
|
||||
|
||||
# adding some tickets to SO
|
||||
cls.customer_so.write({
|
||||
'order_line': [
|
||||
(0, 0, {
|
||||
'event_id': cls.test_event.id,
|
||||
'event_ticket_id': ticket1.id,
|
||||
'product_id': ticket1.product_id.id,
|
||||
'product_uom_qty': cls.TICKET1_COUNT,
|
||||
}), (0, 0, {
|
||||
'event_id': cls.test_event.id,
|
||||
'event_ticket_id': ticket2.id,
|
||||
'product_id': ticket2.product_id.id,
|
||||
'product_uom_qty': cls.TICKET2_COUNT,
|
||||
'price_unit': 50,
|
||||
})
|
||||
]
|
||||
})
|
||||
|
||||
@users('user_sales_salesman')
|
||||
def test_event_crm_sale_customer(self):
|
||||
""" Test a SO with a real customer set on it, check partner propagation
|
||||
as well as group-based lead update. """
|
||||
customer_so = self.env['sale.order'].browse(self.customer_so.id)
|
||||
|
||||
# adding some tickets to SO
|
||||
t1_reg_vals = [
|
||||
dict(customer_data,
|
||||
partner_id=customer_so.partner_id.id,
|
||||
sale_order_line_id=customer_so.order_line[0].id)
|
||||
for customer_data in self.website_customer_data[:self.TICKET1_COUNT]
|
||||
]
|
||||
t1_registrations = self.env['event.registration'].create(t1_reg_vals)
|
||||
|
||||
# check effect: registrations, leads
|
||||
self.assertEqual(self.test_event.registration_ids, t1_registrations)
|
||||
self.assertEqual(len(self.test_rule_order.lead_ids), 1)
|
||||
self.assertEqual(self.test_rule_order_done.lead_ids, self.env['crm.lead'])
|
||||
# check lead converted based on registrations
|
||||
self.assertLeadConvertion(self.test_rule_order, t1_registrations, partner=customer_so.partner_id)
|
||||
|
||||
# SO is confirmed -> missing registrations should be automatically added
|
||||
# and added to the lead as part of the same group
|
||||
customer_so.action_confirm()
|
||||
self.assertEqual(customer_so.state, 'sale')
|
||||
self.assertEqual(len(self.test_event.registration_ids), self.TICKET1_COUNT + self.TICKET2_COUNT)
|
||||
self.assertEqual(len(self.test_rule_order.lead_ids), 1) # no new lead created
|
||||
self.assertEqual(self.test_rule_order_done.lead_ids, self.env['crm.lead']) # this one still not triggered
|
||||
|
||||
# check existing lead has been updated with new registrations
|
||||
self.assertLeadConvertion(self.test_rule_order, self.test_event.registration_ids, partner=customer_so.partner_id)
|
||||
|
||||
# Confirm registrations -> trigger the "DONE" rule, one new lead linked to all
|
||||
# event registrations created in this test as all belong to the same SO
|
||||
self.test_event.registration_ids.write({'state': 'done'})
|
||||
self.assertLeadConvertion(self.test_rule_order_done, self.test_event.registration_ids, partner=customer_so.partner_id)
|
||||
|
||||
@users('user_sales_salesman')
|
||||
def test_event_crm_sale_mixed_group(self):
|
||||
""" Test a mixed sale order line creation. This should not happen in a customer
|
||||
use case but should be supported by the code. """
|
||||
public_partner = self.env.ref('base.public_partner')
|
||||
public_so = self.env['sale.order'].create({
|
||||
'partner_id': public_partner.id,
|
||||
'order_line': [
|
||||
(0, 0, {
|
||||
'event_id': self.test_event.id,
|
||||
'event_ticket_id': self.test_event.event_ticket_ids[0].id,
|
||||
'product_id': self.test_event.event_ticket_ids[0].product_id.id,
|
||||
'product_uom_qty': 2,
|
||||
})
|
||||
]
|
||||
})
|
||||
customer_so = self.env['sale.order'].browse(self.customer_so.id)
|
||||
|
||||
# make a multi-SO create
|
||||
mixed_reg_vals = [
|
||||
dict(self.website_customer_data[0],
|
||||
partner_id=customer_so.partner_id.id,
|
||||
sale_order_line_id=customer_so.order_line[0].id),
|
||||
dict(self.website_customer_data[1],
|
||||
partner_id=customer_so.partner_id.id,
|
||||
sale_order_line_id=customer_so.order_line[0].id),
|
||||
dict(self.website_customer_data[2],
|
||||
partner_id=public_so.partner_id.id,
|
||||
sale_order_line_id=public_so.order_line[0].id),
|
||||
dict(self.website_customer_data[3],
|
||||
partner_id=public_so.partner_id.id,
|
||||
sale_order_line_id=public_so.order_line[0].id),
|
||||
]
|
||||
self.env['event.registration'].create(mixed_reg_vals)
|
||||
|
||||
public_regs = self.test_event.registration_ids.filtered(lambda reg: reg.sale_order_id == public_so)
|
||||
self.assertEqual(len(public_regs), 2)
|
||||
customer_regs = self.test_event.registration_ids.filtered(lambda reg: reg.sale_order_id == customer_so)
|
||||
self.assertEqual(len(customer_regs), 2)
|
||||
self.assertLeadConvertion(self.test_rule_order, public_regs, partner=None)
|
||||
self.assertLeadConvertion(self.test_rule_order, customer_regs, partner=customer_so.partner_id)
|
||||
|
||||
@users('user_sales_salesman')
|
||||
def test_event_crm_sale_public(self):
|
||||
""" Test a SO with a public partner on it, then updated when SO is confirmed.
|
||||
This somehow simulates a simplified website_event_sale flow. """
|
||||
public_partner = self.env.ref('base.public_partner')
|
||||
customer_so = self.env['sale.order'].browse(self.customer_so.id)
|
||||
customer_so.write({
|
||||
'partner_id': public_partner.id,
|
||||
})
|
||||
|
||||
# adding some tickets to SO
|
||||
t1_reg_vals = [
|
||||
dict(customer_data,
|
||||
partner_id=public_partner.id,
|
||||
sale_order_line_id=customer_so.order_line[0].id)
|
||||
for customer_data in self.website_customer_data[:self.TICKET1_COUNT]
|
||||
]
|
||||
t1_registrations = self.env['event.registration'].create(t1_reg_vals)
|
||||
self.assertEqual(self.test_event.registration_ids, t1_registrations)
|
||||
|
||||
# check lead converted based on registrations
|
||||
self.assertLeadConvertion(self.test_rule_order, t1_registrations, partner=None)
|
||||
|
||||
# SO is confirmed -> missing registrations should be automatically added
|
||||
# BUT as public user -> no email -> not taken into account by rule
|
||||
customer_so.action_confirm()
|
||||
self.assertEqual(customer_so.state, 'sale')
|
||||
self.assertEqual(len(self.test_event.registration_ids), self.TICKET1_COUNT + self.TICKET2_COUNT)
|
||||
self.assertLeadConvertion(self.test_rule_order, t1_registrations, partner=None)
|
||||
|
||||
# SO has a customer set -> main contact of lead is updated accordingly
|
||||
customer_so.write({'partner_id': self.event_customer.id})
|
||||
self.assertLeadConvertion(self.test_rule_order, t1_registrations, partner=self.event_customer)
|
||||
|
||||
def test_event_update_lead(self):
|
||||
"""Make sure that we update leads without issues when question's answer is added to an event attendee."""
|
||||
self.env['event.lead.rule'].search([]).write({'active': False})
|
||||
self.env['event.lead.rule'].create({
|
||||
'name': 'test_event_lead_rule',
|
||||
'lead_creation_basis': 'attendee',
|
||||
'lead_creation_trigger': 'create',
|
||||
'event_registration_filter': [['partner_id', '!=', False]],
|
||||
'lead_type': 'lead',
|
||||
})
|
||||
event_registration = self.env['event.registration'].create({
|
||||
'name': 'Event Registration without answers added at first',
|
||||
'event_id': self.test_event.id,
|
||||
'partner_id': self.event_customer.id,
|
||||
})
|
||||
event_registration.write({
|
||||
'registration_answer_ids': [(0, 0, {
|
||||
'question_id': self.test_event.question_ids[1].id,
|
||||
'value_answer_id': self.test_event.question_ids[1].answer_ids[0].id,
|
||||
})]
|
||||
})
|
||||
self.assertIn(self.test_event.question_ids[1].answer_ids[0].name, event_registration.lead_ids[0].description,
|
||||
"lead description not updated with the answer to the question")
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
import time
|
||||
|
||||
from odoo.tests import tagged
|
||||
from odoo.fields import Command
|
||||
|
||||
from odoo.addons.test_event_full.tests.common import TestEventFullCommon
|
||||
|
||||
|
||||
@tagged('post_install', '-at_install')
|
||||
class TestEventTicketPriceRounding(TestEventFullCommon):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
super().setUpClass()
|
||||
|
||||
cls.ticket_product.write({
|
||||
'lst_price': 1.0
|
||||
})
|
||||
|
||||
cls.currency_jpy = cls.env['res.currency'].create({
|
||||
'name': 'JPX',
|
||||
'symbol': '¥',
|
||||
'rounding': 1.0,
|
||||
'rate_ids': [Command.create({'rate': 133.6200, 'name': time.strftime('%Y-%m-%d')})],
|
||||
})
|
||||
|
||||
cls.currency_cad = cls.env['res.currency'].create({
|
||||
'name': 'CXD',
|
||||
'symbol': '$',
|
||||
'rounding': 0.01,
|
||||
'rate_ids': [Command.create({'rate': 1.338800, 'name': time.strftime('%Y-%m-%d')})],
|
||||
})
|
||||
|
||||
cls.pricelist_usd = cls.env['product.pricelist'].create({
|
||||
'name': 'Pricelist USD',
|
||||
'currency_id': cls.env.ref('base.USD').id,
|
||||
})
|
||||
|
||||
cls.pricelist_jpy = cls.env['product.pricelist'].create({
|
||||
'name': 'Pricelist JPY',
|
||||
'currency_id': cls.currency_jpy.id,
|
||||
})
|
||||
|
||||
cls.pricelist_cad = cls.env['product.pricelist'].create({
|
||||
'name': 'Pricelist CAD',
|
||||
'currency_id': cls.currency_cad.id,
|
||||
})
|
||||
|
||||
cls.event_type = cls.env['event.type'].create({
|
||||
'name': 'Test Event Type',
|
||||
'auto_confirm': True,
|
||||
'event_type_ticket_ids': [
|
||||
(0, 0, {
|
||||
'name': 'Test Event Ticket',
|
||||
'product_id': cls.ticket_product.id,
|
||||
'price': 30.0,
|
||||
})
|
||||
],
|
||||
})
|
||||
|
||||
cls.event_ticket = cls.event_type.event_type_ticket_ids[0]
|
||||
|
||||
def test_no_discount_usd(self):
|
||||
ticket = self.event_ticket.with_context(pricelist=self.pricelist_usd.id)
|
||||
ticket._compute_price_reduce()
|
||||
self.assertAlmostEqual(ticket.price_reduce, 30.0, places=6, msg="No discount should be applied for the USD pricelist.")
|
||||
|
||||
def test_no_discount_jpy(self):
|
||||
ticket = self.event_ticket.with_context(pricelist=self.pricelist_jpy.id)
|
||||
ticket._compute_price_reduce()
|
||||
self.assertAlmostEqual(ticket.price_reduce, 30.0, places=6, msg="No discount should be applied for the JPY pricelist.")
|
||||
|
||||
def test_no_discount_cad(self):
|
||||
ticket = self.event_ticket.with_context(pricelist=self.pricelist_cad.id)
|
||||
ticket._compute_price_reduce()
|
||||
self.assertAlmostEqual(ticket.price_reduce, 30.0, places=6, msg="No discount should be applied for the CAD pricelist.")
|
||||
|
|
@ -0,0 +1,158 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from datetime import datetime, timedelta
|
||||
from freezegun import freeze_time
|
||||
|
||||
from odoo import Command, exceptions
|
||||
from odoo.addons.test_event_full.tests.common import TestEventFullCommon
|
||||
from odoo.tests.common import users
|
||||
|
||||
|
||||
class TestEventEvent(TestEventFullCommon):
|
||||
|
||||
@users('event_user')
|
||||
def test_event_create_wtype(self):
|
||||
""" Test a single event creation with a type defining all sub records. """
|
||||
event_type = self.env['event.type'].browse(self.test_event_type.ids)
|
||||
|
||||
event_values = dict(
|
||||
self.event_base_vals,
|
||||
event_type_id=event_type.id,
|
||||
)
|
||||
event = self.env['event.event'].create([event_values])
|
||||
event.write({
|
||||
'event_ticket_ids': [
|
||||
Command.update(
|
||||
event.event_ticket_ids[0].id,
|
||||
{'start_sale_datetime': self.reference_now + timedelta(hours=1)},
|
||||
),
|
||||
Command.update(
|
||||
event.event_ticket_ids[1].id,
|
||||
{'start_sale_datetime': self.reference_now + timedelta(hours=2)},
|
||||
)
|
||||
],
|
||||
})
|
||||
|
||||
# check result
|
||||
self.assertEqual(event.address_id, self.env.user.company_id.partner_id)
|
||||
self.assertTrue(event.auto_confirm)
|
||||
self.assertEqual(event.country_id, self.env.user.company_id.country_id)
|
||||
self.assertEqual(event.date_tz, 'Europe/Paris')
|
||||
self.assertEqual(event.event_booth_count, 4)
|
||||
self.assertEqual(len(event.event_mail_ids), 3)
|
||||
self.assertEqual(len(event.event_ticket_ids), 2)
|
||||
self.assertTrue(event.introduction_menu)
|
||||
self.assertTrue(event.location_menu)
|
||||
self.assertTrue(event.menu_register_cta)
|
||||
self.assertEqual(event.message_partner_ids, self.env.user.partner_id + self.env.user.company_id.partner_id)
|
||||
self.assertEqual(event.note, '<p>Template note</p>')
|
||||
self.assertTrue(event.register_menu)
|
||||
self.assertEqual(len(event.question_ids), 3)
|
||||
self.assertTrue(event.seats_limited)
|
||||
self.assertEqual(event.seats_max, 30)
|
||||
self.assertEqual(event.stage_id, self.stage_def)
|
||||
self.assertEqual(event.tag_ids, self.tags)
|
||||
self.assertTrue(event.website_menu)
|
||||
|
||||
# check time dependent computation: before event
|
||||
with freeze_time(self.reference_now):
|
||||
self.assertFalse(event.is_finished)
|
||||
self.assertFalse(event.is_ongoing)
|
||||
self.assertFalse(event.event_registrations_started)
|
||||
|
||||
# check time dependent computation: registrations started
|
||||
with freeze_time(self.reference_now + timedelta(hours=1)):
|
||||
event.invalidate_model(['is_finished', 'is_ongoing', 'event_registrations_started'])
|
||||
self.assertFalse(event.is_finished)
|
||||
self.assertFalse(event.is_ongoing)
|
||||
self.assertTrue(event.event_registrations_started)
|
||||
|
||||
# check time dependent computation: during event
|
||||
with freeze_time(self.reference_now + timedelta(days=1, hours=1)):
|
||||
event.invalidate_model(['is_finished', 'is_ongoing', 'event_registrations_started'])
|
||||
self.assertFalse(event.is_finished)
|
||||
self.assertTrue(event.is_ongoing)
|
||||
self.assertTrue(event.event_registrations_started)
|
||||
|
||||
@freeze_time('2021-12-01 11:00:00')
|
||||
@users('event_user')
|
||||
def test_event_seats_and_schedulers(self):
|
||||
now = datetime.now() # used to force create_date, as sql is not wrapped by freeze gun
|
||||
self.env.cr._now = now
|
||||
|
||||
test_event = self.env['event.event'].browse(self.test_event.ids)
|
||||
ticket_1 = test_event.event_ticket_ids.filtered(lambda ticket: ticket.name == 'Ticket1')
|
||||
ticket_2 = test_event.event_ticket_ids.filtered(lambda ticket: ticket.name == 'Ticket2')
|
||||
|
||||
# check initial data
|
||||
self.assertTrue(test_event.event_registrations_started)
|
||||
self.assertEqual(test_event.seats_available, 30)
|
||||
self.assertEqual(ticket_1.seats_available, 10)
|
||||
self.assertTrue(ticket_1.sale_available)
|
||||
self.assertEqual(ticket_2.seats_available, 0)
|
||||
self.assertFalse(ticket_2.sale_available)
|
||||
|
||||
# make 9 registrations (let 1 on ticket)
|
||||
with self.mock_mail_gateway():
|
||||
self.env['event.registration'].create([
|
||||
{'create_date': now,
|
||||
'email': 'test.customer.%02d@test.example.com' % x,
|
||||
'phone': '04560011%02d' % x,
|
||||
'event_id': test_event.id,
|
||||
'event_ticket_id': ticket_1.id,
|
||||
'name': 'Customer %d' % x,
|
||||
}
|
||||
for x in range(0, 9)
|
||||
])
|
||||
# generated emails from scheduler
|
||||
self.assertEqual(len(self._new_mails), 9)
|
||||
# event and ticket seats update
|
||||
self.assertEqual(len(test_event.registration_ids), 9)
|
||||
self.assertEqual(test_event.seats_available, 21)
|
||||
self.assertEqual(ticket_1.seats_available, 1)
|
||||
self.assertEqual(ticket_2.seats_available, 0)
|
||||
|
||||
# prevent registration due to ticket limit
|
||||
with self.assertRaises(exceptions.ValidationError):
|
||||
self.env['event.registration'].create([
|
||||
{'create_date': now,
|
||||
'email': 'additional.customer.%02d@test.example.com' % x,
|
||||
'phone': '04560011%02d' % x,
|
||||
'event_id': test_event.id,
|
||||
'event_ticket_id': ticket_1.id,
|
||||
'name': 'Additional Customer %d' % x,
|
||||
}
|
||||
for x in range(0, 2)
|
||||
])
|
||||
|
||||
# make 20 registrations (on free ticket)
|
||||
with self.mock_mail_gateway():
|
||||
self.env['event.registration'].create([
|
||||
{'create_date': now,
|
||||
'email': 'other.customer.%02d@test.example.com' % x,
|
||||
'phone': '04560011%02d' % x,
|
||||
'event_id': test_event.id,
|
||||
'event_ticket_id': ticket_2.id,
|
||||
'name': 'Other Customer %d' % x,
|
||||
}
|
||||
for x in range(0, 20)
|
||||
])
|
||||
# event and ticket seats update
|
||||
self.assertEqual(len(test_event.registration_ids), 29)
|
||||
self.assertEqual(test_event.seats_available, 1)
|
||||
self.assertEqual(ticket_1.seats_available, 1)
|
||||
self.assertEqual(ticket_2.seats_available, 0)
|
||||
|
||||
# prevent registration due to event limit
|
||||
with self.assertRaises(exceptions.ValidationError):
|
||||
self.env['event.registration'].create([
|
||||
{'create_date': now,
|
||||
'email': 'additional.customer.%02d@test.example.com' % x,
|
||||
'phone': '04560011%02d' % x,
|
||||
'event_id': test_event.id,
|
||||
'event_ticket_id': ticket_2.id,
|
||||
'name': 'Additional Customer %d' % x,
|
||||
}
|
||||
for x in range(0, 2)
|
||||
])
|
||||
|
|
@ -0,0 +1,167 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from datetime import datetime, timedelta
|
||||
from freezegun import freeze_time
|
||||
|
||||
from odoo.addons.mail.tests.common import MockEmail
|
||||
from odoo.addons.sms.tests.common import MockSMS
|
||||
from odoo.addons.test_event_full.tests.common import TestWEventCommon
|
||||
from odoo.exceptions import ValidationError
|
||||
from odoo.tools import mute_logger
|
||||
|
||||
class TestTemplateRefModel(TestWEventCommon):
|
||||
|
||||
def test_template_ref_delete_lines(self):
|
||||
""" When deleting a template, related lines should be deleted too """
|
||||
event_type = self.env['event.type'].create({
|
||||
'name': 'Event Type',
|
||||
'default_timezone': 'Europe/Brussels',
|
||||
'event_type_mail_ids': [
|
||||
(0, 0, {
|
||||
'interval_unit': 'now',
|
||||
'interval_type': 'after_sub',
|
||||
'template_ref': 'mail.template,%i' % self.env['ir.model.data']._xmlid_to_res_id('event.event_subscription')}),
|
||||
(0, 0, {
|
||||
'interval_unit': 'now',
|
||||
'interval_type': 'after_sub',
|
||||
'notification_type': 'sms',
|
||||
'template_ref': 'sms.template,%i' % self.env['ir.model.data']._xmlid_to_res_id('event_sms.sms_template_data_event_registration')}),
|
||||
],
|
||||
})
|
||||
|
||||
template_mail = event_type.event_type_mail_ids[0].template_ref
|
||||
template_sms = event_type.event_type_mail_ids[1].template_ref
|
||||
|
||||
event = self.env['event.event'].create({
|
||||
'name': 'event mail template removed',
|
||||
'event_type_id': event_type.id,
|
||||
'date_begin': datetime(2020, 2, 1, 8, 30, 0),
|
||||
'date_end': datetime(2020, 2, 4, 18, 45, 0),
|
||||
'date_tz': 'Europe/Brussels',
|
||||
})
|
||||
self.assertEqual(len(event_type.event_type_mail_ids), 2)
|
||||
self.assertEqual(len(event.event_mail_ids), 2)
|
||||
|
||||
template_mail.unlink()
|
||||
self.assertEqual(len(event_type.event_type_mail_ids.exists()), 1)
|
||||
self.assertEqual(len(event.event_mail_ids.exists()), 1)
|
||||
|
||||
template_sms.unlink()
|
||||
self.assertEqual(len(event_type.event_type_mail_ids.exists()), 0)
|
||||
self.assertEqual(len(event.event_mail_ids.exists()), 0)
|
||||
|
||||
def test_template_ref_model_constraint(self):
|
||||
|
||||
test_cases = [
|
||||
('mail', 'mail.template', True),
|
||||
('mail', 'sms.template', False),
|
||||
('sms', 'sms.template', True),
|
||||
('sms', 'mail.template', False),
|
||||
]
|
||||
|
||||
for notification_type, template_type, valid in test_cases:
|
||||
with self.subTest(notification_type=notification_type, template_type=template_type):
|
||||
if template_type == 'mail.template':
|
||||
template = self.env[template_type].create({
|
||||
'name': 'test template',
|
||||
'model_id': self.env['ir.model']._get_id('event.registration'),
|
||||
})
|
||||
else:
|
||||
template = self.env[template_type].create({
|
||||
'name': 'test template',
|
||||
'body': 'Body Test',
|
||||
'model_id': self.env['ir.model']._get_id('event.registration'),
|
||||
})
|
||||
if not valid:
|
||||
with self.assertRaises(ValidationError) as cm:
|
||||
self.env['event.mail'].create({
|
||||
'event_id': self.event.id,
|
||||
'notification_type': notification_type,
|
||||
'interval_unit': 'now',
|
||||
'interval_type': 'before_event',
|
||||
'template_ref': template,
|
||||
})
|
||||
if notification_type == 'mail':
|
||||
self.assertEqual(str(cm.exception), 'The template which is referenced should be coming from mail.template model.')
|
||||
else:
|
||||
self.assertEqual(str(cm.exception), 'The template which is referenced should be coming from sms.template model.')
|
||||
|
||||
class TestEventSmsMailSchedule(TestWEventCommon, MockEmail, MockSMS):
|
||||
|
||||
@freeze_time('2020-07-06 12:00:00')
|
||||
@mute_logger('odoo.addons.base.models.ir_model', 'odoo.models')
|
||||
def test_event_mail_before_trigger_sent_count(self):
|
||||
""" Emails are sent to both confirmed and unconfirmed attendees.
|
||||
This test checks that the count of sent emails includes the emails sent to unconfirmed ones
|
||||
|
||||
Time in the test is frozen to simulate the following state:
|
||||
|
||||
NOW Event Start Event End
|
||||
12:00 13:00 14:00
|
||||
| | |
|
||||
──────────────────────────────────────►
|
||||
| | time
|
||||
◄─────────────────►
|
||||
3 hours
|
||||
Trigger before event
|
||||
"""
|
||||
self.sms_template_rem = self.env['sms.template'].create({
|
||||
'name': 'Test reminder',
|
||||
'model_id': self.env.ref('event.model_event_registration').id,
|
||||
'body': '{{ object.event_id.organizer_id.name }} reminder',
|
||||
'lang': '{{ object.partner_id.lang }}'
|
||||
})
|
||||
test_event = self.env['event.event'].create({
|
||||
'name': 'TestEventMail',
|
||||
# 'user_id': self.env.ref('base.user_admin').id,
|
||||
'auto_confirm': False,
|
||||
'date_begin': datetime.now() + timedelta(hours=1),
|
||||
'date_end': datetime.now() + timedelta(hours=2),
|
||||
'event_mail_ids': [
|
||||
(0, 0, { # email 3 hours before event
|
||||
'interval_nbr': 3,
|
||||
'interval_unit': 'hours',
|
||||
'interval_type': 'before_event',
|
||||
'template_ref': 'mail.template,%i' % self.env['ir.model.data']._xmlid_to_res_id('event.event_reminder')}),
|
||||
(0, 0, { # sms 3 hours before event
|
||||
'interval_nbr': 3,
|
||||
'interval_unit': 'hours',
|
||||
'interval_type': 'before_event',
|
||||
'notification_type': 'sms',
|
||||
'template_ref': 'sms.template,%i' % self.sms_template_rem.id}),
|
||||
]
|
||||
})
|
||||
mail_scheduler = test_event.event_mail_ids
|
||||
self.assertEqual(len(mail_scheduler), 2, 'There should be two mail schedulers. One for mail one for sms. Cannot perform test')
|
||||
|
||||
# Add registrations
|
||||
self.env['event.registration'].create([{
|
||||
'event_id': test_event.id,
|
||||
'name': 'RegistrationUnconfirmed',
|
||||
'email': 'Registration@Unconfirmed.com',
|
||||
'state': 'draft',
|
||||
}, {
|
||||
'event_id': test_event.id,
|
||||
'name': 'RegistrationCanceled',
|
||||
'email': 'Registration@Canceled.com',
|
||||
'state': 'cancel',
|
||||
}, {
|
||||
'event_id': test_event.id,
|
||||
'name': 'RegistrationConfirmed',
|
||||
'email': 'Registration@Confirmed.com',
|
||||
'state': 'open',
|
||||
}])
|
||||
|
||||
with self.mock_mail_gateway(), self.mockSMSGateway():
|
||||
mail_scheduler.execute()
|
||||
|
||||
self.assertEqual(len(self._new_mails), 2, 'Mails were not created')
|
||||
self.assertEqual(len(self._new_sms), 2, 'SMS were not created')
|
||||
|
||||
self.assertEqual(test_event.seats_expected, 2, 'Wrong number of expected seats (attendees)')
|
||||
|
||||
self.assertEqual(mail_scheduler.filtered(lambda r: r.notification_type == 'mail').mail_count_done, 2,
|
||||
'Wrong Emails Sent Count! Probably emails sent to unconfirmed attendees were not included into the Sent Count')
|
||||
self.assertEqual(mail_scheduler.filtered(lambda r: r.notification_type == 'sms').mail_count_done, 2,
|
||||
'Wrong SMS Sent Count! Probably SMS sent to unconfirmed attendees were not included into the Sent Count')
|
||||
|
|
@ -0,0 +1,213 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
from odoo.addons.test_event_full.tests.common import TestEventFullCommon
|
||||
from odoo.exceptions import AccessError
|
||||
from odoo.tests import tagged
|
||||
from odoo.tests.common import users
|
||||
from odoo.tools import mute_logger
|
||||
|
||||
|
||||
@tagged('security')
|
||||
class TestEventSecurity(TestEventFullCommon):
|
||||
|
||||
@users('user_employee')
|
||||
@mute_logger('odoo.models.unlink', 'odoo.addons.base.models.ir_model')
|
||||
def test_event_access_employee(self):
|
||||
# Event: read ok
|
||||
event = self.test_event.with_user(self.env.user)
|
||||
event.read(['name'])
|
||||
|
||||
# Event: read only
|
||||
with self.assertRaises(AccessError):
|
||||
self.env['event.event'].create({
|
||||
'name': 'TestEvent',
|
||||
'date_begin': datetime.now() + timedelta(days=-1),
|
||||
'date_end': datetime.now() + timedelta(days=1),
|
||||
'seats_limited': True,
|
||||
'seats_max': 10,
|
||||
})
|
||||
with self.assertRaises(AccessError):
|
||||
event.write({
|
||||
'name': 'TestEvent Modified',
|
||||
})
|
||||
|
||||
# Event Type
|
||||
with self.assertRaises(AccessError):
|
||||
self.test_event_type.with_user(self.env.user).read(['name'])
|
||||
with self.assertRaises(AccessError):
|
||||
self.test_event_type.with_user(self.env.user).write({'name': 'Test Write'})
|
||||
|
||||
# Event Stage
|
||||
with self.assertRaises(AccessError):
|
||||
self.env['event.stage'].create({
|
||||
'name': 'TestStage',
|
||||
})
|
||||
|
||||
# Event Registration
|
||||
with self.assertRaises(AccessError):
|
||||
self.env['event.registration'].search([])
|
||||
|
||||
@users('user_eventregistrationdesk')
|
||||
@mute_logger('odoo.models.unlink', 'odoo.addons.base.models.ir_model')
|
||||
def test_event_access_event_registration(self):
|
||||
# Event: read ok
|
||||
event = self.test_event.with_user(self.env.user)
|
||||
event.read(['name', 'user_id', 'kanban_state_label'])
|
||||
|
||||
# Event: read only
|
||||
with self.assertRaises(AccessError):
|
||||
event.name = 'Test'
|
||||
with self.assertRaises(AccessError):
|
||||
event.unlink()
|
||||
|
||||
# Event Registration
|
||||
registration = self.env['event.registration'].create({
|
||||
'event_id': event.id,
|
||||
})
|
||||
self.assertEqual(registration.event_id.name, event.name, 'Registration users should be able to read')
|
||||
registration.name = 'Test write'
|
||||
with self.assertRaises(AccessError):
|
||||
registration.unlink()
|
||||
|
||||
@users('user_eventuser')
|
||||
@mute_logger('odoo.models.unlink', 'odoo.addons.base.models.ir_model')
|
||||
def test_event_access_event_user(self):
|
||||
# Event
|
||||
event = self.test_event.with_user(self.env.user)
|
||||
event.read(['name', 'user_id', 'kanban_state_label'])
|
||||
event.write({'name': 'New name'})
|
||||
self.env['event.event'].create({
|
||||
'name': 'Event',
|
||||
'date_begin': datetime.now() + timedelta(days=-1),
|
||||
'date_end': datetime.now() + timedelta(days=1),
|
||||
})
|
||||
|
||||
# Event: cannot unlink
|
||||
with self.assertRaises(AccessError):
|
||||
event.unlink()
|
||||
|
||||
# Event Type
|
||||
with self.assertRaises(AccessError):
|
||||
self.env['event.type'].create({
|
||||
'name': 'ManagerEventType',
|
||||
'event_type_mail_ids': [(5, 0), (0, 0, {
|
||||
'interval_nbr': 1, 'interval_unit': 'days', 'interval_type': 'before_event',
|
||||
'template_ref': 'mail.template,%i' % self.env['ir.model.data']._xmlid_to_res_id('event.event_reminder')})]
|
||||
})
|
||||
|
||||
@users('user_eventmanager')
|
||||
@mute_logger('odoo.models.unlink', 'odoo.addons.base.models.ir_model')
|
||||
def test_event_access_event_manager(self):
|
||||
# Event Type
|
||||
event_type = self.env['event.type'].create({
|
||||
'name': 'ManagerEventType',
|
||||
'event_type_mail_ids': [(5, 0), (0, 0, {
|
||||
'interval_nbr': 1, 'interval_unit': 'days', 'interval_type': 'before_event',
|
||||
'template_ref': 'mail.template,%i' % self.env['ir.model.data']._xmlid_to_res_id('event.event_reminder')})]
|
||||
})
|
||||
event_type.write({'name': 'New Name'})
|
||||
|
||||
# Event
|
||||
event = self.env['event.event'].create({
|
||||
'name': 'ManagerEvent',
|
||||
'date_begin': datetime.now() + timedelta(days=-1),
|
||||
'date_end': datetime.now() + timedelta(days=1),
|
||||
})
|
||||
event.write({'name': 'New Event Name'})
|
||||
|
||||
# Event Stage
|
||||
stage = self.env['event.stage'].create({'name': 'test'})
|
||||
stage.write({'name': 'ManagerTest'})
|
||||
event.write({'stage_id': stage.id})
|
||||
|
||||
# Event Registration
|
||||
registration = self.env['event.registration'].create({'event_id': event.id, 'name': 'Myself'})
|
||||
registration.write({'name': 'Myself2'})
|
||||
registration.unlink()
|
||||
|
||||
event.unlink()
|
||||
stage.unlink()
|
||||
event_type.unlink()
|
||||
|
||||
# Settings access rights required to enable some features
|
||||
self.user_eventmanager.write({'groups_id': [
|
||||
(3, self.env.ref('base.group_system').id),
|
||||
(4, self.env.ref('base.group_erp_manager').id)
|
||||
]})
|
||||
with self.assertRaises(AccessError):
|
||||
event_config = self.env['res.config.settings'].with_user(self.user_eventmanager).create({
|
||||
})
|
||||
event_config.execute()
|
||||
|
||||
def test_implied_groups(self):
|
||||
"""Test that the implied groups are correctly set.
|
||||
|
||||
- Event Manager imply Event User
|
||||
- Event User imply Registration user
|
||||
"""
|
||||
# Event Manager
|
||||
self.assertTrue(
|
||||
self.user_eventmanager.has_group('event.group_event_user'),
|
||||
'The event manager group must imply the event user group')
|
||||
self.assertTrue(
|
||||
self.user_eventmanager.has_group('event.group_event_registration_desk'),
|
||||
'The event manager group must imply the registration user group')
|
||||
|
||||
# Event User
|
||||
self.assertTrue(
|
||||
self.user_eventuser.has_group('event.group_event_registration_desk'),
|
||||
'The event user group must imply the event user group')
|
||||
self.assertFalse(
|
||||
self.user_eventuser.has_group('event.group_event_manager'),
|
||||
'The event user group must not imply the event user group')
|
||||
|
||||
# Registration User
|
||||
self.assertFalse(
|
||||
self.user_eventregistrationdesk.has_group('event.group_event_manager'),
|
||||
'The event registration group must not imply the event user manager')
|
||||
self.assertFalse(
|
||||
self.user_eventregistrationdesk.has_group('event.group_event_user'),
|
||||
'The event registration group must not imply the event user group')
|
||||
|
||||
def test_multi_companies(self):
|
||||
"""Test ACLs with multi company. """
|
||||
company_1 = self.env.ref("base.main_company")
|
||||
company_2 = self.env['res.company'].create({'name': 'Company 2'})
|
||||
user_company_1 = self.user_eventuser
|
||||
|
||||
event_company_1, event_company_2 = self.env['event.event'].create([
|
||||
{
|
||||
'name': 'Event Company 1',
|
||||
'date_begin': datetime.now() + timedelta(days=-1),
|
||||
'date_end': datetime.now() + timedelta(days=1),
|
||||
'company_id': company_1.id,
|
||||
}, {
|
||||
'name': 'Event Company 2',
|
||||
'date_begin': datetime.now() + timedelta(days=-1),
|
||||
'date_end': datetime.now() + timedelta(days=1),
|
||||
'company_id': company_2.id,
|
||||
}
|
||||
])
|
||||
|
||||
registration_company_1, registration_company_2 = self.env['event.registration'].create([
|
||||
{
|
||||
'name': 'Registration Company 1',
|
||||
'event_id': event_company_1.id,
|
||||
'company_id': company_1.id,
|
||||
}, {
|
||||
'name': 'Registration Company 2',
|
||||
'event_id': event_company_2.id,
|
||||
'company_id': company_2.id,
|
||||
}
|
||||
])
|
||||
|
||||
result = self.env['event.event'].with_user(user_company_1).search([])
|
||||
self.assertIn(event_company_1, result, 'You must be able to read the events in your company')
|
||||
self.assertNotIn(event_company_2, result, 'You must not be able to read events outside of your company')
|
||||
|
||||
result = self.env['event.registration'].with_user(user_company_1).search([])
|
||||
self.assertIn(registration_company_1, result, 'You must be able to read the registrations in your company')
|
||||
self.assertNotIn(registration_company_2, result, 'You must not be able to read registrations outside of your company')
|
||||
|
|
@ -0,0 +1,483 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from datetime import timedelta
|
||||
from freezegun import freeze_time
|
||||
|
||||
from odoo.addons.test_event_full.tests.common import TestEventFullCommon
|
||||
from odoo.addons.website.tests.test_performance import UtilPerf
|
||||
from odoo.tests.common import users, warmup, Form
|
||||
from odoo.tests import tagged
|
||||
|
||||
|
||||
@tagged('event_performance', 'post_install', '-at_install', '-standard')
|
||||
class EventPerformanceCase(TestEventFullCommon):
|
||||
|
||||
def setUp(self):
|
||||
super(EventPerformanceCase, self).setUp()
|
||||
# patch registry to simulate a ready environment
|
||||
self.patch(self.env.registry, 'ready', True)
|
||||
self._flush_tracking()
|
||||
|
||||
def _flush_tracking(self):
|
||||
""" Force the creation of tracking values notably, and ensure tests are
|
||||
reproducible. """
|
||||
self.env.flush_all()
|
||||
self.cr.flush()
|
||||
|
||||
|
||||
@tagged('event_performance', 'post_install', '-at_install', '-standard')
|
||||
class TestEventPerformance(EventPerformanceCase):
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_event_create_batch_notype(self):
|
||||
""" Test multiple event creation (import) """
|
||||
batch_size = 20
|
||||
|
||||
# simple without type involved
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=335): # tef 335
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
event_values = [
|
||||
dict(self.event_base_vals,
|
||||
website_menu=False)
|
||||
for x in range(batch_size)
|
||||
]
|
||||
self.env['event.event'].create(event_values)
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_event_create_batch_notype_website(self):
|
||||
""" Test multiple event creation (import) """
|
||||
batch_size = 20
|
||||
|
||||
# simple without type involved + website
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=5368): # tef 4944 / com 4943
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
event_values = [
|
||||
dict(self.event_base_vals,
|
||||
website_menu=True
|
||||
)
|
||||
for x in range(batch_size)
|
||||
]
|
||||
self.env['event.event'].create(event_values)
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_event_create_batch_wtype(self):
|
||||
""" Test multiple event creation (import) """
|
||||
batch_size = 20
|
||||
event_type = self.env['event.type'].browse(self.test_event_type.ids)
|
||||
|
||||
# complex with type
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=439): # 439
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
event_values = [
|
||||
dict(self.event_base_vals,
|
||||
event_type_id=event_type.id,
|
||||
website_menu=False,
|
||||
)
|
||||
for x in range(batch_size)
|
||||
]
|
||||
self.env['event.event'].create(event_values)
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_event_create_batch_wtype_website(self):
|
||||
""" Test multiple event creation (import) """
|
||||
batch_size = 20
|
||||
event_type = self.env['event.type'].browse(self.test_event_type.ids)
|
||||
|
||||
# complex with type + website
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=5480): # tef 5056 / com 5055
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
event_values = [
|
||||
dict(self.event_base_vals,
|
||||
event_type_id=event_type.id,
|
||||
)
|
||||
for x in range(batch_size)
|
||||
]
|
||||
self.env['event.event'].create(event_values)
|
||||
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_event_create_form_notype(self):
|
||||
""" Test a single event creation using Form """
|
||||
has_social = 'social_menu' in self.env['event.event'] # otherwise view may crash in enterprise
|
||||
|
||||
# no type, no website
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=206): # tef 160 / com 160
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
# Require for `website_menu` to be visible
|
||||
# <div name="event_menu_configuration" groups="base.group_no_one">
|
||||
with self.debug_mode():
|
||||
with Form(self.env['event.event']) as event_form:
|
||||
event_form.name = 'Test Event'
|
||||
event_form.date_begin = self.reference_now + timedelta(days=1)
|
||||
event_form.date_end = self.reference_now + timedelta(days=5)
|
||||
event_form.website_menu = False
|
||||
if has_social:
|
||||
event_form.social_menu = False
|
||||
_event = event_form.save()
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_event_create_form_notype_website(self):
|
||||
""" Test a single event creation using Form """
|
||||
has_social = 'social_menu' in self.env['event.event'] # otherwise view may crash in enterprise
|
||||
|
||||
# no type, website
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=666): # tef 565 / com 566
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
# Require for `website_menu` to be visible
|
||||
# <div name="event_menu_configuration" groups="base.group_no_one">
|
||||
with self.debug_mode():
|
||||
with Form(self.env['event.event']) as event_form:
|
||||
event_form.name = 'Test Event'
|
||||
event_form.date_begin = self.reference_now + timedelta(days=1)
|
||||
event_form.date_end = self.reference_now + timedelta(days=5)
|
||||
event_form.website_menu = True
|
||||
if has_social:
|
||||
event_form.social_menu = False
|
||||
_event = event_form.save()
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_event_create_form_type_website(self):
|
||||
""" Test a single event creation using Form """
|
||||
event_type = self.env['event.type'].browse(self.test_event_type.ids)
|
||||
has_social = 'social_menu' in self.env['event.event'] # otherwise view may crash in enterprise
|
||||
|
||||
# type and website
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=692): # tef 593 / com 596
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
# Require for `website_menu` to be visible
|
||||
# <div name="event_menu_configuration" groups="base.group_no_one">
|
||||
with self.debug_mode():
|
||||
with Form(self.env['event.event']) as event_form:
|
||||
event_form.name = 'Test Event'
|
||||
event_form.date_begin = self.reference_now + timedelta(days=1)
|
||||
event_form.date_end = self.reference_now + timedelta(days=5)
|
||||
event_form.event_type_id = event_type
|
||||
if has_social:
|
||||
event_form.social_menu = False
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_event_create_single_notype(self):
|
||||
""" Test a single event creation """
|
||||
# simple without type involved
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=31): # 31
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
event_values = dict(
|
||||
self.event_base_vals,
|
||||
website_menu=False
|
||||
)
|
||||
self.env['event.event'].create([event_values])
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_event_create_single_notype_website(self):
|
||||
""" Test a single event creation """
|
||||
# simple without type involved + website
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=352): # tef 327 / com 326
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
event_values = dict(
|
||||
self.event_base_vals,
|
||||
website_menu=True
|
||||
)
|
||||
self.env['event.event'].create([event_values])
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_event_create_single_wtype(self):
|
||||
""" Test a single event creation """
|
||||
event_type = self.env['event.type'].browse(self.test_event_type.ids)
|
||||
|
||||
# complex with type
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=58): # 58
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
event_values = dict(
|
||||
self.event_base_vals,
|
||||
event_type_id=event_type.id,
|
||||
website_menu=False
|
||||
)
|
||||
self.env['event.event'].create([event_values])
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_event_create_single_wtype_website(self):
|
||||
""" Test a single event creation """
|
||||
event_type = self.env['event.type'].browse(self.test_event_type.ids)
|
||||
|
||||
# complex with type + website
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=387): # tef 362 / com 361
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
event_values = dict(
|
||||
self.event_base_vals,
|
||||
event_type_id=event_type.id,
|
||||
)
|
||||
self.env['event.event'].create([event_values])
|
||||
|
||||
|
||||
@tagged('event_performance', 'registration_performance', 'post_install', '-at_install', '-standard')
|
||||
class TestRegistrationPerformance(EventPerformanceCase):
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_registration_create_batch(self):
|
||||
""" Test multiple registrations creation (batch of 10 without partner
|
||||
and batch of 10 with partner)
|
||||
|
||||
# TODO: with self.profile(collectors=['sql']) as _profile:
|
||||
"""
|
||||
event = self.env['event.event'].browse(self.test_event.ids)
|
||||
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=720): # tef only: 674? - com runbot 716 - ent runbot 719
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
registration_values = [
|
||||
dict(reg_data,
|
||||
event_id=event.id)
|
||||
for reg_data in self.customer_data
|
||||
]
|
||||
registration_values += [
|
||||
{'event_id': event.id,
|
||||
'partner_id': partner.id,
|
||||
} for partner in self.partners
|
||||
]
|
||||
_registrations = self.env['event.registration'].create(registration_values)
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_registration_create_batch_nolead(self):
|
||||
""" Test multiple registrations creation (batch of 10 without partner
|
||||
and batch of 10 with partner)
|
||||
|
||||
# TODO: with self.profile(collectors=['sql']) as _profile:
|
||||
"""
|
||||
event = self.env['event.event'].browse(self.test_event.ids)
|
||||
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=210): # tef 167 / com runbot 206
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
registration_values = [
|
||||
dict(reg_data,
|
||||
event_id=event.id)
|
||||
for reg_data in self.customer_data
|
||||
]
|
||||
registration_values += [
|
||||
{'event_id': event.id,
|
||||
'partner_id': partner.id,
|
||||
} for partner in self.partners
|
||||
]
|
||||
_registrations = self.env['event.registration'].with_context(event_lead_rule_skip=True).create(registration_values)
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_registration_create_batch_website(self):
|
||||
""" Test multiple registrations creation (batch of 10 without partner
|
||||
and batch of 10 with partner) with some additional informations (register
|
||||
form like) """
|
||||
event = self.env['event.event'].browse(self.test_event.ids)
|
||||
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=731): # tef only: 685? - com runbot 727
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
registration_values = [
|
||||
dict(reg_data,
|
||||
event_id=event.id)
|
||||
for reg_data in self.website_customer_data
|
||||
]
|
||||
registration_values += [
|
||||
{'event_id': event.id,
|
||||
'partner_id': partner.id,
|
||||
'registration_answer_ids': self.website_customer_data[0]['registration_answer_ids'],
|
||||
} for partner in self.partners
|
||||
]
|
||||
_registrations = self.env['event.registration'].create(registration_values)
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_registration_create_form_customer(self):
|
||||
""" Test a single registration creation using Form """
|
||||
event = self.env['event.event'].browse(self.test_event.ids)
|
||||
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=231): # tef only: 210? - com runbot 216
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
with Form(self.env['event.registration']) as reg_form:
|
||||
reg_form.event_id = event
|
||||
reg_form.email = 'email.00@test.example.com'
|
||||
reg_form.mobile = '0456999999'
|
||||
reg_form.name = 'My Customer'
|
||||
reg_form.phone = '0456000000'
|
||||
_registration = reg_form.save()
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_registration_create_form_partner(self):
|
||||
""" Test a single registration creation using Form """
|
||||
event = self.env['event.event'].browse(self.test_event.ids)
|
||||
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=233): # tef only: 213? - com runbot 217
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
with Form(self.env['event.registration']) as reg_form:
|
||||
reg_form.event_id = event
|
||||
reg_form.partner_id = self.partners[0]
|
||||
_registration = reg_form.save()
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_registration_create_form_partner_nolead(self):
|
||||
""" Test a single registration creation using Form """
|
||||
event = self.env['event.event'].browse(self.test_event.ids)
|
||||
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=124): # tef 107 / com 109
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
with Form(self.env['event.registration'].with_context(event_lead_rule_skip=True)) as reg_form:
|
||||
reg_form.event_id = event
|
||||
reg_form.partner_id = self.partners[0]
|
||||
_registration = reg_form.save()
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_registration_create_single_customer(self):
|
||||
""" Test a single registration creation """
|
||||
event = self.env['event.event'].browse(self.test_event.ids)
|
||||
|
||||
# simple customer data
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=143): # tef only: 135? - com runbot 140
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
registration_values = dict(
|
||||
self.customer_data[0],
|
||||
event_id=event.id)
|
||||
_registration = self.env['event.registration'].create([registration_values])
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_registration_create_single_partner(self):
|
||||
""" Test a single registration creation """
|
||||
event = self.env['event.event'].browse(self.test_event.ids)
|
||||
|
||||
# partner-based customer
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=149): # tef only: 142? - com runbot 146
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
registration_values = {
|
||||
'event_id': event.id,
|
||||
'partner_id': self.partners[0].id,
|
||||
}
|
||||
_registration = self.env['event.registration'].create([registration_values])
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_registration_create_single_partner_nolead(self):
|
||||
""" Test a single registration creation """
|
||||
event = self.env['event.event'].browse(self.test_event.ids)
|
||||
|
||||
# partner-based customer
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=46): # tef 41 / com 43
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
registration_values = {
|
||||
'event_id': event.id,
|
||||
'partner_id': self.partners[0].id,
|
||||
}
|
||||
_registration = self.env['event.registration'].with_context(event_lead_rule_skip=True).create([registration_values])
|
||||
|
||||
@users('event_user')
|
||||
@warmup
|
||||
def test_registration_create_single_website(self):
|
||||
""" Test a single registration creation """
|
||||
event = self.env['event.event'].browse(self.test_event.ids)
|
||||
|
||||
# website customer data
|
||||
with freeze_time(self.reference_now), self.assertQueryCount(event_user=151): # tef only: 142? - com runbot 146
|
||||
self.env.cr._now = self.reference_now # force create_date to check schedulers
|
||||
registration_values = dict(
|
||||
self.website_customer_data[0],
|
||||
event_id=event.id)
|
||||
_registration = self.env['event.registration'].create([registration_values])
|
||||
|
||||
|
||||
@tagged('event_performance', 'event_online', 'post_install', '-at_install', '-standard')
|
||||
class TestOnlineEventPerformance(EventPerformanceCase, UtilPerf):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
super(TestOnlineEventPerformance, cls).setUpClass()
|
||||
# if website_livechat is installed, disable it
|
||||
if 'channel_id' in cls.env['website']:
|
||||
cls.env['website'].search([]).channel_id = False
|
||||
|
||||
cash_journal = cls.env['account.journal'].create({
|
||||
'name': 'Cash - Test',
|
||||
'type': 'cash',
|
||||
'code': 'CASH - Test'
|
||||
})
|
||||
cls.env['payment.provider'].search([('code', '=', 'test')]).write({
|
||||
'journal_id': cash_journal.id,
|
||||
'state': 'test'
|
||||
})
|
||||
|
||||
# clean even page to make it reproducible
|
||||
cls.env['event.event'].search([('name', '!=', 'Test Event')]).write({'active': False})
|
||||
# create noise for events
|
||||
cls.noise_events = cls.env['event.event'].create([
|
||||
{'name': 'Event %02d' % idx,
|
||||
'date_begin': cls.reference_now + timedelta(days=(-2 + int(idx/10))),
|
||||
'date_end': cls.reference_now + timedelta(days=5),
|
||||
'is_published': True,
|
||||
}
|
||||
for idx in range(0, 50)
|
||||
])
|
||||
|
||||
def _test_url_open(self, url):
|
||||
url += ('?' not in url and '?' or '') + '&debug=disable-t-cache'
|
||||
return self.url_open(url)
|
||||
|
||||
@warmup
|
||||
def test_event_page_event_manager(self):
|
||||
# website customer data
|
||||
with freeze_time(self.reference_now):
|
||||
self.authenticate('user_eventmanager', 'user_eventmanager')
|
||||
with self.assertQueryCount(default=36): # tef 35
|
||||
self._test_url_open('/event/%i' % self.test_event.id)
|
||||
|
||||
@warmup
|
||||
def test_event_page_public(self):
|
||||
# website customer data
|
||||
with freeze_time(self.reference_now):
|
||||
self.authenticate(None, None)
|
||||
with self.assertQueryCount(default=27):
|
||||
self._test_url_open('/event/%i' % self.test_event.id)
|
||||
|
||||
@warmup
|
||||
def test_events_browse_event_manager(self):
|
||||
# website customer data
|
||||
with freeze_time(self.reference_now):
|
||||
self.authenticate('user_eventmanager', 'user_eventmanager')
|
||||
with self.assertQueryCount(default=39): # tef 38
|
||||
self._test_url_open('/event')
|
||||
|
||||
@warmup
|
||||
def test_events_browse_public(self):
|
||||
# website customer data
|
||||
with freeze_time(self.reference_now):
|
||||
self.authenticate(None, None)
|
||||
with self.assertQueryCount(default=28):
|
||||
self._test_url_open('/event')
|
||||
|
||||
# @warmup
|
||||
# def test_register_public(self):
|
||||
# with freeze_time(self.reference_now + timedelta(hours=3)): # be sure sales has started
|
||||
# self.assertTrue(self.test_event.event_registrations_started)
|
||||
# self.authenticate(None, None)
|
||||
# with self.assertQueryCount(default=99999): # tef only: 1110
|
||||
# self.browser_js(
|
||||
# '/event/%i/register' % self.test_event.id,
|
||||
# 'odoo.__DEBUG__.services["web_tour.tour"].run("wevent_performance_register")',
|
||||
# 'odoo.__DEBUG__.services["web_tour.tour"].tours.wevent_performance_register.ready',
|
||||
# login=None,
|
||||
# timeout=200,
|
||||
# )
|
||||
|
||||
# # minimal checkup, to be improved in future tests independently from performance
|
||||
# self.assertEqual(len(self.test_event.registration_ids), 3)
|
||||
# self.assertEqual(len(self.test_event.registration_ids.visitor_id), 1)
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from freezegun import freeze_time
|
||||
|
||||
from odoo import tests
|
||||
from odoo.addons.test_event_full.tests.common import TestWEventCommon
|
||||
|
||||
|
||||
@tests.common.tagged('event_online', 'post_install', '-at_install')
|
||||
class TestWEventRegister(TestWEventCommon):
|
||||
|
||||
def test_register(self):
|
||||
with freeze_time(self.reference_now, tick=True):
|
||||
self.browser_js(
|
||||
'/event',
|
||||
'odoo.__DEBUG__.services["web_tour.tour"].run("wevent_register")',
|
||||
'odoo.__DEBUG__.services["web_tour.tour"].tours.wevent_register.ready',
|
||||
login=None
|
||||
)
|
||||
new_registrations = self.event.registration_ids
|
||||
visitor = new_registrations.visitor_id
|
||||
|
||||
# check registration content
|
||||
self.assertEqual(len(new_registrations), 2)
|
||||
self.assertEqual(
|
||||
set(new_registrations.mapped("name")),
|
||||
set(["Raoulette Poiluchette", "Michel Tractopelle"])
|
||||
)
|
||||
self.assertEqual(
|
||||
set(new_registrations.mapped("phone")),
|
||||
set(["0456112233", "0456332211"])
|
||||
)
|
||||
self.assertEqual(
|
||||
set(new_registrations.mapped("email")),
|
||||
set(["raoulette@example.com", "michel@example.com"])
|
||||
)
|
||||
|
||||
# check visitor stored information
|
||||
self.assertEqual(visitor.display_name, "Raoulette Poiluchette")
|
||||
self.assertEqual(visitor.event_registration_ids, new_registrations)
|
||||
self.assertEqual(visitor.partner_id, self.env['res.partner'])
|
||||
self.assertEqual(visitor.mobile, "0456112233")
|
||||
self.assertEqual(visitor.email, "raoulette@example.com")
|
||||
Loading…
Add table
Add a link
Reference in a new issue