| 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')) |