Debian Codegraph @

addons/marketing_card/tests/test_campaign.py

raw
1 import base64
2 from datetime import datetime
3 from lxml import html
4 from unittest.mock import patch
5
6 from odoo import exceptions
7 from odoo.tools import mute_logger
8 from odoo.tests.common import users
9 from odoo.tests import Form, HttpCase, tagged, warmup
10 from odoo.addons.mail.tests.common import MailCase
11 from odoo.addons.marketing_card.controllers.marketing_card import SOCIAL_NETWORK_USER_AGENTS
12
13 from .common import MarketingCardCommon, mock_image_render, VALID_JPEG
14
15
16 def _extract_values_from_document(rendered_document):
17 return {
18 'body': rendered_document.find('.//div[@id="body"]'),
19 'header': rendered_document.find('.//span[@id="header"]'),
20 'subheader': rendered_document.find('.//span[@id="subheader"]'),
21 'section': rendered_document.find('.//span[@id="section"]'),
22 'sub_section1': rendered_document.find('.//span[@id="sub_section1"]'),
23 'sub_section2': rendered_document.find('.//span[@id="sub_section2"]'),
24 'button': rendered_document.find('.//span[@id="button"]'),
25 'image1': rendered_document.find('.//img[@id="image1"]'),
26 'image2': rendered_document.find('.//img[@id="image2"]'),
27 }
28
29
30 class TestMarketingCardMail(MailCase, MarketingCardCommon):
31
32 def assertSentMailCorrectCard(self, sent_mails, cards):
33 IrHttp = self.env['ir.http']
34 sent_cards = self.env['card.card']
35 for sent_mail in sent_mails:
36 record_id = int(sent_mail['object_id'].split('-')[0])
37 card = cards.filtered(lambda card: card.res_id == record_id)
38 self.assertEqual(len(card), 1)
39 sent_cards += card
40 campaign_base_url = card.campaign_id.get_base_url()
41 preview_url = f"{campaign_base_url}/cards/{IrHttp._slug(card)}/preview"
42 image_url = f"{campaign_base_url}/cards/{IrHttp._slug(card)}/card.jpg"
43 self.assertIn(f'<a href="{preview_url}"', sent_mail['body'])
44 self.assertIn(f'<img src="{image_url}"', sent_mail['body'])
45 self.assertEqual(sent_cards, cards)
46
47 @users('marketing_card_user')
48 @warmup
49 @mute_logger('odoo.addons.mail.models.mail_mail')
50 def test_campaign_send_mailing(self):
51 campaign = self.campaign.with_user(self.env.user)
52 self.env.user.sudo().group_ids += self.env.ref('mass_mailing.group_mass_mailing_user')
53 partners = self.env['res.partner'].sudo().create([{'name': f'Part{n}', 'email': f'partn{n}@test.lan'} for n in range(7)])
54 mailing_context = campaign.action_share().get('context') | {
55 'default_email_from': '[email protected]',
56 'default_mailing_domain': [('id', 'in', partners.ids[:5])],
57 'default_reply_to': '[email protected]',
58 }
59 mailing = Form(self.env['mailing.mailing'].with_context(mailing_context)).save()
60 mailing.body_html = mailing.body_arch # normally the js html_field would fill this in
61
62 # sending mailing before generating cards sends to no-one
63 self.assertTrue(mailing.card_requires_sync_count)
64 with self.assertRaises(exceptions.UserError, msg="There are no recipients selected."):
65 mailing._action_send_mail()
66
67 with self.assertRaises(exceptions.UserError, msg="You should update all the cards before scheduling a mailing."):
68 mailing.action_launch()
69
70 # once cards are updated they can be sent
71 with self.mock_image_renderer():
72 mailing.action_update_cards()
73 self.assertEqual(len(self._wkhtmltoimage_bodies), 5)
74
75 self.assertFalse(mailing.card_requires_sync_count)
76 mailing.action_launch()
77 mailing.action_cancel()
78
79 # modifying the domain such that there are missing cards prevents sending again
80 mailing.mailing_domain = [('id', 'in', partners.ids[1:6])]
81 mailing._compute_card_requires_sync_count()
82 self.assertTrue(mailing.card_requires_sync_count)
83 with self.assertRaises(exceptions.UserError, msg="You should update all the cards before scheduling a mailing."):
84 mailing.action_launch()
85
86 # updating when the campaign was not modified only updates cards that need to be
87 with self.mock_image_renderer():
88 mailing.action_update_cards()
89 self.assertEqual(len(self._wkhtmltoimage_bodies), 1)
90
91 self.assertFalse(mailing.card_requires_sync_count)
92
93 # modifying the campaign should lead to all cards relevant being re-rendered
94 campaign.content_header = "New Header"
95 mailing._compute_card_requires_sync_count()
96 self.assertTrue(mailing.card_requires_sync_count)
97 with self.mock_image_renderer():
98 mailing.action_update_cards()
99 self.assertEqual(len(self._wkhtmltoimage_bodies), 5)
100
101 with self.mock_mail_gateway(), self.assertQueryCount(54):
102 mailing._action_send_mail()
103
104 cards = self.env['card.card'].search([('campaign_id', '=', campaign.id)])
105 self.assertEqual(len(cards), 6)
106 sent_cards = cards.filtered(lambda card: not card.requires_sync)
107 self.assertEqual(len(sent_cards), 5)
108 self.assertEqual(len(self._mails), 5)
109
110 self.assertSentMailCorrectCard(self._mails, sent_cards)
111
112 @users('marketing_card_user')
113 @mute_logger('odoo.addons.mail.models.mail_mail')
114 def test_campaign_send_mailing_with_duplicates(self):
115 # set a low batch size to make sure mailing "seen list" does not affect card mailings
116 # as it is based on traces existing with some email -> traces created in batches with mail.mail
117 self.env['ir.config_parameter'].sudo().set_param('mail.batch_size', 5)
118
119 campaign = self.campaign.with_user(self.env.user)
120 self.env.user.sudo().group_ids += self.env.ref('mass_mailing.group_mass_mailing_user')
121 partners = self.env['res.partner'].sudo().create([{'name': f'Part{n}', 'email': f'email{n % 3}@test.lan'} for n in range(10)])
122 mailing_context = campaign.action_share().get('context') | {
123 'default_email_from': '[email protected]',
124 'default_mailing_domain': [('id', 'in', partners.ids)],
125 'default_reply_to': '[email protected]',
126 }
127 mailing = Form(self.env['mailing.mailing'].with_context(mailing_context)).save()
128 mailing.body_html = mailing.body_arch # normally the js html_field would fill this in
129
130 with self.mock_image_renderer():
131 mailing.action_update_cards()
132
133 cards = self.env['card.card'].search([('campaign_id', '=', campaign.id)])
134 self.assertEqual(len(cards), 10)
135
136 with self.mock_mail_gateway():
137 mailing._action_send_mail()
138 self.assertEqual(len(self._mails), 10)
139
140 self.assertSentMailCorrectCard(self._mails, cards)
141
142
143 class TestMarketingCardRender(MarketingCardCommon):
144
145 @users('marketing_card_user')
146 def test_campaign(self):
147 campaign = self.campaign.with_user(self.env.user)
148
149 with self.mock_image_renderer():
150 campaign.write({
151 'content_header': 'Come and See',
152 'content_header_dyn': False,
153 'content_header_color': '#CC8888',
154 })
155 self.assertTrue(campaign.image_preview)
156
157 role_values = _extract_values_from_document(html.fromstring(self._wkhtmltoimage_bodies[0]))
158 self.assertEqual(role_values['body'].attrib['style'], "background-image: url('data:image/png;base64,');")
159 self.assertEqual(role_values['header'].text, 'Come and See')
160 self.assertEqual(role_values['header'].attrib['style'], 'color: #CC8888;')
161 self.assertEqual(role_values['subheader'].text, 'John')
162 self.assertEqual(role_values['section'].text, 'Contact')
163 self.assertEqual(role_values['sub_section1'].text, '[email protected]')
164 self.assertFalse(role_values['sub_section2'])
165 self.assertEqual(role_values['button'].text, 'Button')
166 self.assertFalse(role_values['image1'])
167 self.assertFalse(role_values['image2'])
168
169 campaign.action_preview()
170 card = self.env['card.card'].search([
171 ('campaign_id', '=', campaign.id),
172 ('active', '=', False)
173 ])
174 self.assertEqual(len(card), 1)
175 self.assertTrue(card.image)
176 self.assertTrue(card.requires_sync)
177 self.assertEqual(card.res_id, self.partners[0].id)
178
179 # second record, modified tags
180
181 with self.mock_image_renderer():
182 campaign.preview_record_ref = self.partners[1]
183 self.assertTrue(campaign.image_preview)
184 role_values = _extract_values_from_document(html.fromstring(self._wkhtmltoimage_bodies[0]))
185 self.assertEqual(role_values['body'].attrib['style'], "background-image: url('data:image/png;base64,');")
186 self.assertEqual(role_values['subheader'].text, 'Bob')
187 self.assertEqual(role_values['sub_section1'].text, '[email protected]')
188 self.assertEqual(role_values['sub_section2'].text, '+32 123 446 789')
189 self.assertFalse(role_values['image1'])
190 self.assertEqual(role_values['image2'].attrib['src'], f'data:image/png;base64,{base64.b64encode(VALID_JPEG).decode()}')
191
192 campaign.action_preview()
193 cards = self.env['card.card'].search([
194 ('campaign_id', '=', campaign.id),
195 ('active', '=', False)
196 ])
197 self.assertEqual(cards.mapped('requires_sync'), [True] * 2)
198 self.assertEqual(cards.mapped('active'), [False] * 2)
199 self.assertTrue(cards.mapped('res_id'), self.partners.ids)
200
201 # update previewed record fields
202
203 with self.mock_image_renderer():
204 campaign.preview_record_ref.sudo().name = 'An updated name'
205 self.assertFalse(self._wkhtmltoimage_bodies, 'Updating the preview record does not refresh the preview.')
206
207 # mismatch preview
208
209 with patch('odoo.addons.marketing_card.models.card_campaign.CardCampaign._get_model_selection',
210 lambda Model: [('res.partner', 'Partner'), ('res.users', 'User')]):
211
212 # mismatches without cards
213 self.assertEqual(self.static_campaign.res_model, 'res.partner')
214 self.assertFalse(self.static_campaign.card_ids)
215 self.static_campaign.preview_record_ref = self.env.user
216 self.assertEqual(self.static_campaign.res_model, 'res.users')
217 self.static_campaign.preview_record_ref = self.partners[1]
218 self.assertEqual(self.static_campaign.res_model, 'res.partner')
219
220 # mismatch with card
221 self.env['card.card'].sudo().create({'campaign_id': self.static_campaign.id, 'res_id': 1})
222
223 self.assertTrue(self.static_campaign.card_ids)
224 with self.assertRaises(exceptions.ValidationError):
225 self.static_campaign.preview_record_ref = self.env.user
226 self.assertTrue(self.static_campaign.res_model)
227 self.assertEqual(self.static_campaign.res_model, 'res.partner')
228
229 # match with card
230 self.static_campaign.preview_record_ref = self.partners[0]
231 self.assertEqual(self.static_campaign.res_model, 'res.partner')
232
233 @mock_image_render
234 def test_fetch_datetime(self):
235 """Fetching a datetime field should attempt to translate it in the relevant timezone."""
236 freeze_dt = datetime(2020, 5, 5, 12, 0, 0)
237 campaign = self.campaign.with_user(self.env.user)
238 campaign.write({
239 'content_header': False,
240 'content_header_dyn': True,
241 'content_header_path': 'write_date',
242 })
243 with self.mock_datetime_and_now(freeze_dt):
244 campaign.preview_record_ref.name = 'test_fetch_datetime'
245 timezones = [None, 'Europe/Brussels', 'Asia/Tokyo']
246 timezone_result_headers = []
247 for tz in timezones:
248 # force find different timezones to check the returned time
249 with patch(
250 'odoo.addons.mail.models.models.Base._mail_get_timezone',
251 lambda model: tz
252 ):
253 timezone_result_headers.append(
254 campaign._get_card_element_values(campaign.preview_record_ref)['header']
255 )
256 utc_header, brussels_header, tokyo_header = timezone_result_headers
257 self.assertEqual(
258 utc_header, datetime(2020, 5, 5, 12, 0, 0)
259 )
260 self.assertEqual(
261 brussels_header, datetime(2020, 5, 5, 14, 0, 0)
262 )
263 self.assertEqual(
264 tokyo_header, datetime(2020, 5, 5, 21, 0, 0)
265 )
266
267
268 @tagged('post_install', '-at_install')
269 class TestMarketingCardRouting(HttpCase, MarketingCardCommon):
270
271 @mock_image_render
272 def test_campaign_stats(self):
273 partners = self.env['res.partner'].create([{'name': f'Part{n}', 'email': f'partn{n}@test.lan'} for n in range(20)])
274 cards = self.campaign._update_cards([('id', 'in', partners.ids)]).sorted('res_id')
275 self.assertEqual(len(cards), 20)
276 self.assertEqual(self.campaign.card_count, 20)
277 self.assertEqual(self.campaign.card_click_count, 0)
278 self.assertEqual(self.campaign.card_share_count, 0)
279 self.assertListEqual(cards.mapped('image'), [base64.b64encode(VALID_JPEG)] * 20)
280 self.assertListEqual(cards.mapped('share_status'), [False] * 20)
281 self.assertListEqual(cards.mapped('requires_sync'), [False] * 20)
282
283 # user checks preview
284 self.campaign.preview_record_ref = partners[0]
285 card = cards.filtered(lambda card: card.res_id == partners[0].id)
286 self.assertEqual(self.campaign.action_preview()['url'], card._get_path('preview'))
287 self.url_open(card._get_path('preview'))
288 image_request_headers = self.url_open(card._get_card_url()).headers
289 self.assertEqual(image_request_headers.get('Content-Type'), 'image/jpeg')
290 self.assertTrue(image_request_headers.get('Content-Length'))
291 self.assertTrue(card.image)
292 self.assertEqual(card.share_status, 'visited')
293 self.assertEqual(card.active, False, "preview card was updated and is thus considered not valid")
294 self.campaign.flush_recordset()
295 self.assertEqual(self.campaign.card_count, 19)
296 self.assertEqual(self.campaign.card_click_count, 0)
297 self.assertEqual(self.campaign.card_share_count, 0, 'A regular user fetching the card should not count as a share.')
298
299 # recipient opens the card they received
300 card.active = True # reset as if it were never used as preview
301 image_request_headers = self.url_open(card._get_card_url())
302 self.campaign.flush_recordset()
303 self.assertEqual(self.campaign.card_count, 20)
304 self.assertEqual(self.campaign.card_click_count, 1)
305 self.assertEqual(self.campaign.card_share_count, 0, 'A regular user fetching the card should not count as a share.')
306
307 # user publishes redirect url, prompting social network crawler to check open-graph data
308 self.opener.headers['User-Agent'] = f'v1 {SOCIAL_NETWORK_USER_AGENTS[0]} v1.2/'
309 opengraph_view = html.fromstring(self.url_open(card._get_redirect_url()).content)
310 self.assertTrue(opengraph_view is not None, 'Crawler should get a valid html page as response')
311 opengraph_image_url_element = opengraph_view.find('.//meta[@property="og:image"]')
312 self.assertTrue(opengraph_image_url_element is not None, 'page should contain image opengraph node')
313 opengraph_image_url = opengraph_image_url_element.attrib.get('content')
314 self.assertTrue(opengraph_image_url)
315 self.assertEqual(opengraph_image_url, card._get_card_url())
316
317 image_request_headers = self.url_open(opengraph_image_url).headers
318 self.assertEqual(image_request_headers.get('Content-Type'), 'image/jpeg')
319 self.assertTrue(image_request_headers.get('Content-Length'))
320
321 self.campaign.flush_recordset()
322 self.assertEqual(self.campaign.card_count, 20)
323 self.assertEqual(self.campaign.card_click_count, 1)
324 self.assertEqual(self.campaign.card_share_count, 1, "A crawler fetching the card is considered a share.")
325 self.assertEqual(cards[0].share_status, 'shared')
326
327 # someone clicks the redirect url on the social network platform
328 self.assertEqual(self.campaign.target_url_click_count, 0)
329 self.opener.headers['User-Agent'] = 'someuseragent'
330 redirect_response = self.url_open(card._get_redirect_url(), allow_redirects=False)
331 self.assertEqual(redirect_response.status_code, 303)
332 self.assertEqual(redirect_response._next.url, self.campaign.link_tracker_id.short_url)
333 self.url_open(redirect_response._next.url, allow_redirects=False)
334 self.assertEqual(self.campaign.target_url_click_count, 1)
335
336 cards[1:10].share_status = 'visited'
337 cards[10:].share_status = 'shared'
338 self.assertEqual(self.campaign.card_count, 20)
339 self.assertEqual(self.campaign.card_click_count, 20, 'Shared cards are considered implicitly visited')
340 self.assertEqual(self.campaign.card_share_count, 11)
341
342
343 class TestMarketingCardSecurity(MarketingCardCommon):
344
345 @users('marketing_card_manager')
346 @mute_logger('odoo.addons.mail.models.mail_render_mixin')
347 def test_campaign_field_paths(self):
348 """Check that card updates are performed as the current user."""
349 # restrict reading from partner states (flush to apply new rule)
350 rules = self.env['ir.rule'].sudo().create([{
351 'name': 'marketing card user read partner state',
352 'domain_force': repr([(0, '=', 1)]),
353 'groups': self.env.ref('marketing_card.marketing_card_group_user').ids,
354 'model_id': self.env['ir.model']._get_id('res.country.state'),
355 'perm_read': True,
356 }, {
357 'name': 'system user read partner state',
358 'domain_force': repr([(1, '=', 1)]),
359 'groups': self.env.ref('base.group_system').ids,
360 'model_id': self.env['ir.model']._get_id('res.country.state'),
361 'perm_read': True,
362 }])
363 rules.flush_recordset()
364 # set a state as sudo and invalidate to force fetch as test user
365 self.marketing_card_user.partner_id.state_id = self.env['res.country.state'].sudo().create({
366 'name': 'test marketing card state',
367 'code': 'ZZ',
368 'country_id': self.env.ref('base.be').id,
369 })
370 self.marketing_card_user.partner_id.state_id.invalidate_recordset()
371
372 campaign = self.campaign.with_user(self.env.user)
373 campaign.preview_record_ref = self.marketing_card_user.partner_id
374 # should work fine with accessible fields
375 campaign._update_cards([('id', '=', self.marketing_card_user.partner_id.id)])
376 with self.assertRaises(exceptions.UserError):
377 campaign.write({
378 'content_header_dyn': True,
379 'content_header_path': 'state_id.name',
380 })
381 # flush to compute image_preview
382 campaign.flush_recordset()
383
384 campaign.with_user(self.system_admin).write({
385 'content_header_dyn': True,
386 'content_header_path': 'state_id.name',
387 })
388 campaign.with_user(self.system_admin).flush_recordset()
389 # clear state from cache as it was fetched by the admin for the preview render
390 self.marketing_card_user.partner_id.state_id.invalidate_recordset()
391
392 with self.assertRaises(exceptions.UserError), self.mock_image_renderer():
393 campaign._update_cards([('id', '=', self.marketing_card_user.partner_id.id)])
394 self.assertFalse(self._wkhtmltoimage_bodies, 'There should have been no render on illegal fields')
395
396 with self.mock_image_renderer():
397 campaign.with_user(self.system_admin)._update_cards([('id', '=', self.marketing_card_user.partner_id.id)])
398 self.assertIn('test marketing card state', self._wkhtmltoimage_bodies[0])
399
400 def test_campaign_ownership(self):
401 campaign_as_manager = self.campaign.with_user(self.marketing_card_manager)
402 campaign_as_owner = self.campaign.with_user(self.marketing_card_user)
403 campaign_as_other = self.campaign.with_user(self.marketing_card_user_2)
404
405 with self.assertRaises(exceptions.AccessError):
406 campaign_as_other.content_header = 'Hello'
407 campaign_as_owner.content_header = 'Hi'
408 campaign_as_manager.content_header = 'Hoy'
409
410 with self.assertRaises(exceptions.AccessError):
411 campaign_as_other.unlink()
412 campaign_as_owner.unlink()
413
414 def test_mail_render_security_body_html(self):
415 """Asserts body_html of card.campaign cannot be written to.
416
417 See _check_access_right_dynamic_template override.
418 """
419 campaign = self.campaign.with_user(self.marketing_card_manager)
420 # Will raise ZeroDivisionError if the template is executed
421 arbitrary_qweb = """
422 <img t-attf-src="data:image/png;base64,{{1 / 0}}"/>
423 """
424
425 with self.assertRaisesRegex(exceptions.AccessError, 'You are not allowed to modify'):
426 campaign.body_html = arbitrary_qweb
427 # Flush to simulate the end of the transaction and trigger all recomputes
428 self.env.cr.flush()
429
430 # Ensure that the value is well not written in db, nor on the current campaign, nor on the related.
431 self.assertTrue(arbitrary_qweb not in campaign.body_html)
432 self.assertTrue(arbitrary_qweb not in campaign.card_template_id.body)
433
434 with self.assertRaisesRegex(exceptions.AccessError, 'You are not allowed to modify'):
435 campaign.card_template_id.body = arbitrary_qweb
436
437 def test_mail_render_security_render_field_write_access(self):
438 """Check the rendered fields on card.campaign are not both rendered and writeable.
439
440 See _check_access_right_dynamic_template override.
441 """
442 CardCampaign = self.env['card.campaign'].with_user(self.marketing_card_manager)
443 # Asserts all render fields are related to card.template, not stored on the campaign itself, and readonly
444 # If one of the render fields doesn't fulfil this assumption, the `_unrestricted_rendering = True` must be
445 # reconsidered for security reasons.
446 self.assertTrue(
447 all(
448 field.related_field.model_name == 'card.template'
449 and not field.store
450 and not field.readonly
451 for field in CardCampaign._fields.values() if hasattr(field, 'render_engine')
452 )
453 )
454 # Asserts the manager doesn't have write access to card.template
455 self.assertFalse(CardCampaign.card_template_id.has_access('write'))