mirror of
https://github.com/bringout/oca-ocb-core.git
synced 2026-04-21 23:32:01 +02:00
340 lines
13 KiB
Python
340 lines
13 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from unittest.mock import patch
|
|
|
|
from psycopg2 import IntegrityError
|
|
|
|
from odoo.exceptions import UserError, ValidationError
|
|
from odoo.fields import Command
|
|
from odoo.tests import Form, TransactionCase, tagged
|
|
from odoo.tools import mute_logger
|
|
|
|
|
|
@tagged('post_install', '-at_install')
|
|
class TestLoyalty(TransactionCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
|
|
cls.program = cls.env['loyalty.program'].create({
|
|
'name': 'Test Program',
|
|
'reward_ids': [(0, 0, {})],
|
|
})
|
|
cls.product = cls.env['product.product'].with_context(default_taxes_id=False).create({
|
|
'name': "Test Product",
|
|
'type': 'consu',
|
|
'list_price': 20.0,
|
|
})
|
|
|
|
def create_program_with_code(self, code):
|
|
return self.env['loyalty.program'].create({
|
|
'name': "Discount delivery",
|
|
'program_type': 'promo_code',
|
|
'rule_ids': [Command.create({
|
|
'code': code,
|
|
'minimum_amount': 0,
|
|
})],
|
|
})
|
|
|
|
def test_loyalty_program_default_values(self):
|
|
# Test that the default values are correctly set when creating a new program
|
|
program = self.env['loyalty.program'].create({'name': "Test"})
|
|
self._check_promotion_default_values(program)
|
|
|
|
def _check_promotion_default_values(self, program):
|
|
self.assertEqual(program.program_type, 'promotion')
|
|
self.assertEqual(program.trigger, 'auto')
|
|
self.assertEqual(program.portal_visible, False)
|
|
self.assertTrue(program.rule_ids)
|
|
self.assertTrue(len(program.rule_ids) == 1)
|
|
self.assertEqual(program.rule_ids.reward_point_amount, 1)
|
|
self.assertEqual(program.rule_ids.reward_point_mode, 'order')
|
|
self.assertEqual(program.rule_ids.minimum_amount, 50)
|
|
self.assertEqual(program.rule_ids.minimum_qty, 0)
|
|
self.assertTrue(program.reward_ids)
|
|
self.assertTrue(len(program.reward_ids) == 1)
|
|
self.assertEqual(program.reward_ids.required_points, 1)
|
|
self.assertEqual(program.reward_ids.discount, 10)
|
|
self.assertFalse(program.communication_plan_ids)
|
|
|
|
def test_loyalty_program_default_values_in_form(self):
|
|
# Test that the default values are correctly set when creating a new program in a form
|
|
with Form(self.env['loyalty.program']) as program_form:
|
|
program_form.name = 'Test'
|
|
program = program_form.save()
|
|
self._check_promotion_default_values(program)
|
|
|
|
def test_discount_product_unlink(self):
|
|
# Test that we can not unlink discount line product id
|
|
with mute_logger('odoo.sql_db'), self.assertRaises(IntegrityError):
|
|
self.program.reward_ids.discount_line_product_id.unlink()
|
|
|
|
def test_loyalty_mail(self):
|
|
# Test basic loyalty_mail functionalities
|
|
loyalty_card_model_id = self.env.ref('loyalty.model_loyalty_card')
|
|
create_tmpl, fifty_tmpl, hundred_tmpl = self.env['mail.template'].create([
|
|
{
|
|
'name': 'CREATE',
|
|
'model_id': loyalty_card_model_id.id,
|
|
},
|
|
{
|
|
'name': '50 points',
|
|
'model_id': loyalty_card_model_id.id,
|
|
},
|
|
{
|
|
'name': '100 points',
|
|
'model_id': loyalty_card_model_id.id,
|
|
},
|
|
])
|
|
self.program.write({'communication_plan_ids': [
|
|
(0, 0, {
|
|
'program_id': self.program.id,
|
|
'trigger': 'create',
|
|
'mail_template_id': create_tmpl.id,
|
|
}),
|
|
(0, 0, {
|
|
'program_id': self.program.id,
|
|
'trigger': 'points_reach',
|
|
'points': 50,
|
|
'mail_template_id': fifty_tmpl.id,
|
|
}),
|
|
(0, 0, {
|
|
'program_id': self.program.id,
|
|
'trigger': 'points_reach',
|
|
'points': 100,
|
|
'mail_template_id': hundred_tmpl.id,
|
|
}),
|
|
]})
|
|
|
|
sent_mails = self.env['mail.template']
|
|
|
|
def mock_send_mail(self, *args, **kwargs):
|
|
nonlocal sent_mails
|
|
sent_mails |= self
|
|
|
|
partner = self.env['res.partner'].create({'name': 'Test Partner'})
|
|
with patch('odoo.addons.mail.models.mail_template.MailTemplate.send_mail', new=mock_send_mail):
|
|
# Send mail at creation
|
|
coupon = self.env['loyalty.card'].create({
|
|
'program_id': self.program.id,
|
|
'partner_id': partner.id,
|
|
'points': 0,
|
|
})
|
|
self.assertEqual(sent_mails, create_tmpl)
|
|
sent_mails = self.env['mail.template']
|
|
# 50 points mail
|
|
coupon.points = 50
|
|
self.assertEqual(sent_mails, fifty_tmpl)
|
|
sent_mails = self.env['mail.template']
|
|
# Check that it does not get sent again
|
|
coupon.points = 99
|
|
self.assertFalse(sent_mails)
|
|
# 100 points mail
|
|
coupon.points = 100
|
|
self.assertEqual(sent_mails, hundred_tmpl)
|
|
sent_mails = self.env['mail.template']
|
|
# Reset and go straight to 100 points
|
|
coupon.points = 0
|
|
self.assertFalse(sent_mails)
|
|
coupon.points = 100
|
|
self.assertEqual(sent_mails, hundred_tmpl)
|
|
|
|
def test_loyalty_program_preserve_reward_upon_writing(self):
|
|
self.program.program_type = 'buy_x_get_y'
|
|
# recompute of rewards
|
|
self.program.flush_recordset(['reward_ids'])
|
|
|
|
self.program.write({
|
|
'reward_ids': [
|
|
Command.create({
|
|
'description': 'Test Product',
|
|
}),
|
|
],
|
|
})
|
|
self.assertTrue(all(r.reward_type == 'product' for r in self.program.reward_ids))
|
|
|
|
def test_loyalty_program_preserve_reward_with_always_edit(self):
|
|
with Form(self.env['loyalty.program']) as program_form:
|
|
program_form.name = 'Test'
|
|
program_form.program_type = 'buy_x_get_y'
|
|
program_form.reward_ids.remove(0)
|
|
with program_form.reward_ids.new() as new_reward:
|
|
new_reward.reward_product_qty = 2
|
|
program = program_form.save()
|
|
self.assertEqual(program.reward_ids.reward_type, 'product')
|
|
self.assertEqual(program.reward_ids.reward_product_qty, 2)
|
|
|
|
def test_archiving_unarchiving(self):
|
|
self.program.write({
|
|
'reward_ids': [
|
|
Command.create({
|
|
'description': 'Test Product',
|
|
}),
|
|
],
|
|
})
|
|
before_archived_reward_ids = self.program.reward_ids
|
|
self.program.action_archive()
|
|
self.program.action_unarchive()
|
|
after_archived_reward_ids = self.program.reward_ids
|
|
self.assertEqual(before_archived_reward_ids, after_archived_reward_ids)
|
|
|
|
def test_prevent_archive_pricelist_linked_to_program(self):
|
|
self.program.pricelist_ids = demo_pricelist = self.env['product.pricelist'].create({
|
|
'name': "Demo"
|
|
})
|
|
with self.assertRaises(UserError):
|
|
demo_pricelist.action_archive()
|
|
self.program.action_archive()
|
|
demo_pricelist.action_archive()
|
|
|
|
def test_prevent_archiving_product_linked_to_active_loyalty_reward(self):
|
|
self.program.program_type = 'promotion'
|
|
self.program.flush_recordset()
|
|
reward = self.env['loyalty.reward'].create({
|
|
'program_id': self.program.id,
|
|
'discount_line_product_id': self.product.id,
|
|
})
|
|
self.program.write({
|
|
'reward_ids': [Command.link(reward.id)],
|
|
})
|
|
with self.assertRaises(ValidationError):
|
|
self.product.action_archive()
|
|
self.program.action_archive()
|
|
self.product.action_archive()
|
|
|
|
def test_prevent_archiving_product_used_for_discount_reward(self):
|
|
"""
|
|
Ensure products cannot be archived while they have a specific program active.
|
|
"""
|
|
self.program.write({
|
|
'name': f"50% Discount on {self.product.name}",
|
|
'program_type': 'promotion',
|
|
'reward_ids': [Command.create({
|
|
'discount': 50.0,
|
|
'discount_applicability': 'specific',
|
|
'discount_product_ids': self.product.ids,
|
|
})],
|
|
})
|
|
with self.assertRaises(ValidationError):
|
|
self.product.action_archive()
|
|
self.program.action_archive()
|
|
self.product.action_archive()
|
|
self.assertFalse(self.product.active)
|
|
|
|
def test_prevent_archiving_product_when_archiving_program(self):
|
|
"""
|
|
Test prevent archiving a product when archiving a "Buy X Get Y" program.
|
|
We just have to archive the free product that has been created while creating
|
|
the program itself not the product we already had before.
|
|
"""
|
|
loyalty_program = self.env['loyalty.program'].create({
|
|
'name': 'Test Program',
|
|
'program_type': 'buy_x_get_y',
|
|
'reward_ids': [
|
|
Command.create({
|
|
'description': 'Test Product',
|
|
'reward_product_id': self.product.id,
|
|
'reward_type': 'product'
|
|
}),
|
|
],
|
|
})
|
|
loyalty_program.action_archive()
|
|
# Make sure that the main product didn't get archived
|
|
self.assertTrue(self.product.active)
|
|
|
|
def test_merge_loyalty_cards(self):
|
|
"""Test merging nominative loyalty cards from source partners to a destination partner
|
|
when partners are merged.
|
|
"""
|
|
program = self.env['loyalty.program'].create({
|
|
'name': 'Test Program',
|
|
'is_nominative': True,
|
|
'applies_on': 'both',
|
|
})
|
|
|
|
partner_1, partner_2, dest_partner = self.env['res.partner'].create([
|
|
{'name': 'Source Partner 1'},
|
|
{'name': 'Source Partner 2'},
|
|
{'name': 'Destination Partner'},
|
|
])
|
|
self.env['loyalty.card'].create([
|
|
{
|
|
'partner_id': partner_1.id,
|
|
'program_id': program.id,
|
|
'points': 10
|
|
}, {
|
|
'partner_id': partner_2.id,
|
|
'program_id': program.id,
|
|
'points': 20
|
|
}, {
|
|
'partner_id': dest_partner.id,
|
|
'program_id': program.id,
|
|
'points': 30
|
|
}
|
|
])
|
|
|
|
self.env['base.partner.merge.automatic.wizard']._merge(
|
|
[partner_1.id, partner_2.id, dest_partner.id], dest_partner
|
|
)
|
|
|
|
dest_partner_loyalty_cards = self.env['loyalty.card'].search([
|
|
('partner_id', '=', dest_partner.id),
|
|
('program_id', '=', program.id),
|
|
])
|
|
|
|
self.assertEqual(len(dest_partner_loyalty_cards), 1)
|
|
self.assertEqual(dest_partner_loyalty_cards.points, 60)
|
|
self.assertFalse(self.env['loyalty.card'].search([
|
|
('partner_id', 'in', [partner_1.id, partner_2.id]),
|
|
]))
|
|
|
|
def test_card_description_on_tag_change(self):
|
|
product_tag = self.env['product.tag'].create({'name': 'Multiple Products'})
|
|
product1 = self.product
|
|
product1.product_tag_ids = product_tag
|
|
self.env['product.product'].create({
|
|
'name': 'Test Product 2',
|
|
'list_price': 30.0,
|
|
'product_tag_ids': product_tag,
|
|
})
|
|
reward = self.env['loyalty.reward'].create({
|
|
'program_id': self.program.id,
|
|
'reward_type': 'product',
|
|
'reward_product_id': product1.id,
|
|
})
|
|
reward_description_single_product = reward.description
|
|
reward.reward_product_tag_id = product_tag
|
|
reward_description_product_tag = reward.description
|
|
self.assertNotEqual(
|
|
reward_description_single_product,
|
|
reward_description_product_tag,
|
|
"Reward description should be changed after adding a tag"
|
|
)
|
|
self.assertEqual(
|
|
reward_description_product_tag,
|
|
"Free Product - [Test Product, Test Product 2]",
|
|
"Reward description for reward with tag should be 'Free Product - [Test Product, Test Product 2]'"
|
|
)
|
|
|
|
def test_prevent_unarchive_when_conflicting_active_program_exists(self):
|
|
"""Unarchiving a program should fail if another active program already has the same rule
|
|
code."""
|
|
program = self.create_program_with_code("FREE")
|
|
program.action_archive()
|
|
# create another active program with the same rule code
|
|
self.create_program_with_code("FREE")
|
|
# attempt to unarchive the first program
|
|
with self.assertRaises(ValidationError):
|
|
program.action_unarchive()
|
|
|
|
def test_prevent_unarchive_when_batch_contains_duplicate_codes(self):
|
|
"""Unarchiving multiple programs at once should fail if they share the same rule code."""
|
|
program1 = self.create_program_with_code("FREE")
|
|
program1.action_archive()
|
|
# create another program with the same rule code and archive it
|
|
program2 = self.create_program_with_code("FREE")
|
|
program2.action_archive()
|
|
# attempt to unarchive both programs together
|
|
with self.assertRaises(ValidationError):
|
|
(program1 + program2).action_unarchive()
|