mirror of
https://github.com/bringout/oca-ocb-sale.git
synced 2026-04-26 11:32:07 +02:00
149 lines
6.2 KiB
Python
149 lines
6.2 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from datetime import datetime, timedelta
|
|
from freezegun import freeze_time
|
|
|
|
from odoo.api import Environment
|
|
from odoo.tests import tagged
|
|
from odoo.tools import SQL
|
|
|
|
from odoo.addons.base.tests.common import BaseCommon
|
|
from odoo.addons.http_routing.tests.common import MockRequest
|
|
|
|
|
|
@tagged('post_install', '-at_install')
|
|
class TestWebsiteSequence(BaseCommon):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
|
|
cls.website = cls.env.ref('website.default_website')
|
|
cls.public_user = cls.env.ref('base.public_user')
|
|
|
|
ProductTemplate = cls.env['product.template']
|
|
product_templates = ProductTemplate.search([])
|
|
# if stock is installed we can't archive since there is orderpoints
|
|
if 'orderpoint_ids' in cls.env['product.product']:
|
|
product_templates.mapped('product_variant_ids.orderpoint_ids').write({'active': False})
|
|
# if pos loyalty is installed we can't archive since there are loyalty rules and rewards
|
|
if 'loyalty.program' in cls.env:
|
|
programs = cls.env['loyalty.program'].search([])
|
|
programs.active = False
|
|
programs.coupon_ids.unlink()
|
|
programs.unlink()
|
|
# The "Service on Timesheet" product cannot be archived nor deleted via ORM
|
|
if time_product := cls.env.ref('sale_timesheet.time_product', raise_if_not_found=False):
|
|
product_templates -= time_product.product_tmpl_id
|
|
cls.env.cr.execute(SQL(
|
|
'UPDATE product_template SET active = false WHERE id = %s',
|
|
time_product.product_tmpl_id.id,
|
|
))
|
|
product_templates.write({'active': False})
|
|
cls.product_tmpls = cls.p1, cls.p2, cls.p3, cls.p4 = ProductTemplate.create([{
|
|
'name': 'First Product',
|
|
'website_sequence': 100,
|
|
}, {
|
|
'name': 'Second Product',
|
|
'website_sequence': 180,
|
|
}, {
|
|
'name': 'Third Product',
|
|
'website_sequence': 225,
|
|
}, {
|
|
'name': 'Last Product',
|
|
'website_sequence': 250,
|
|
}])
|
|
|
|
def get_product_sort_mapping(self, label):
|
|
context = dict(self.env.context, website_id=self.website.id, lang='en_US')
|
|
env = Environment(self.env.cr, self.public_user.id, context)
|
|
with MockRequest(env, website=self.website.with_env(env)) as req:
|
|
product_sort_mapping = req.env['website']._get_product_sort_mapping()
|
|
return next(k for k, v in product_sort_mapping if v == label)
|
|
|
|
def get_sorted_products(self, order, products=None):
|
|
products = products or self.product_tmpls
|
|
return products.search(
|
|
[('id', 'in', products.ids)],
|
|
order=order,
|
|
)
|
|
|
|
def assertProductOrdering(self, products, order):
|
|
"""Assert `products` are sorted by `order`.
|
|
|
|
:param records products: The products or product templates to check.
|
|
:param str order: Expect ordering, in the same format as used by `search`.
|
|
"""
|
|
expected = self.get_sorted_products(order, products=products)
|
|
self.assertSequenceEqual(products, expected, f"Products should be ordered on '{order}'")
|
|
|
|
def test_01_website_sequence(self):
|
|
sequence_order = self.get_product_sort_mapping("Featured")
|
|
self.assertProductOrdering(self.p1 + self.p2 + self.p3 + self.p4, sequence_order)
|
|
# 100:1, 180:2, 225:3, 250:4
|
|
self.p2.set_sequence_down()
|
|
# 100:1, 180:3, 225:2, 250:4
|
|
self.assertProductOrdering(self.p1 + self.p3 + self.p2 + self.p4, sequence_order)
|
|
self.p4.set_sequence_up()
|
|
# 100:1, 180:3, 225:4, 250:2
|
|
self.assertProductOrdering(self.p1 + self.p3 + self.p4 + self.p2, sequence_order)
|
|
self.p2.set_sequence_top()
|
|
# 95:2, 100:1, 180:3, 225:4
|
|
self.assertProductOrdering(self.p2 + self.p1 + self.p3 + self.p4, sequence_order)
|
|
self.p1.set_sequence_bottom()
|
|
# 95:2, 180:3, 225:4, 230:1
|
|
self.assertProductOrdering(self.p2 + self.p3 + self.p4 + self.p1, sequence_order)
|
|
|
|
current_products = self.get_sorted_products(sequence_order)
|
|
current_sequences = current_products.mapped('website_sequence')
|
|
self.assertEqual(current_sequences, [95, 180, 225, 230], "Wrong sequence order (2)")
|
|
|
|
self.p2.website_sequence = 1
|
|
self.p3.set_sequence_top()
|
|
# -4:3, 1:2, 225:4, 230:1
|
|
self.assertEqual(self.p3.website_sequence, -4, "`website_sequence` should go below 0")
|
|
|
|
new_product = self.env['product.template'].create({
|
|
'name': 'Last Newly Created Product',
|
|
})
|
|
current_products += new_product
|
|
|
|
self.assertEqual(
|
|
self.get_sorted_products(sequence_order, current_products)[-1],
|
|
new_product,
|
|
"New product should be last",
|
|
)
|
|
|
|
def test_02_newest_arrivals(self):
|
|
def toggle_publish(products, delta=timedelta(seconds=5)):
|
|
publish_date = datetime.now()
|
|
for product in products:
|
|
publish_date += delta
|
|
with freeze_time(publish_date):
|
|
product.website_publish_button()
|
|
product.flush_recordset() # force computations
|
|
|
|
newest_arrival_order = self.get_product_sort_mapping("Newest Arrivals")
|
|
|
|
toggle_publish(self.product_tmpls)
|
|
# Products were published sequentially,
|
|
# so first product is "oldest" arrival & last product is "newest" arrival
|
|
target = self.product_tmpls[::-1]
|
|
self.assertTrue(all(self.product_tmpls.mapped('is_published')))
|
|
self.assertProductOrdering(target, newest_arrival_order)
|
|
|
|
publish_dates = self.product_tmpls.mapped('publish_date')
|
|
toggle_publish(self.product_tmpls)
|
|
self.assertFalse(any(self.product_tmpls.mapped('is_published')))
|
|
self.assertSequenceEqual(
|
|
self.product_tmpls.mapped('publish_date'),
|
|
publish_dates,
|
|
"Unpublishing should not affect publishing date",
|
|
)
|
|
|
|
toggle_publish(self.p2, delta=timedelta(days=1))
|
|
self.assertEqual(
|
|
self.get_sorted_products(newest_arrival_order)[0],
|
|
self.p2,
|
|
"Most recently published product should appear first",
|
|
)
|