oca/oca-ocb-sale
2
0
Fork 0
mirror of https://github.com/bringout/oca-ocb-sale.git synced 2026-04-27 09:52:02 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

19.0 vanilla

Browse source
This commit is contained in:
Ernad Husremovic 2026-03-09 09:32:12 +01:00
parent 79f83631d5
commit 73afc09215
6267 changed files with 1534193 additions and 1130106 deletions
Download patch file Download diff file Expand all files Collapse all files

501
odoo-bringout-oca-ocb-website_sale/website_sale/tests/test_sale_process.py
View file

@ -1,113 +1,107 @@
# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
import logging
import lxml.html
import odoo.tests
from odoo.fields import Command
from odoo.tests import tagged
from odoo import api, Command
from odoo.addons.base.tests.common import HttpCaseWithUserDemo, TransactionCaseWithUserDemo, HttpCaseWithUserPortal
from odoo.addons.website_sale.controllers.main import WebsiteSale
from odoo.addons.website.tools import MockRequest
from odoo.addons.base.tests.common import HttpCaseWithUserDemo
from odoo.addons.website_sale.tests.common import WebsiteSaleCommon
from odoo.addons.website.tests.common import HttpCaseWithWebsiteUser
_logger = logging.getLogger(__name__)
@odoo.tests.tagged('post_install', '-at_install')
class TestUi(HttpCaseWithUserDemo):
@tagged('post_install', '-at_install')
class TestSaleProcess(HttpCaseWithUserDemo, WebsiteSaleCommon, HttpCaseWithWebsiteUser):
def setUp(self):
super(TestUi, self).setUp()
product_product_7 = self.env['product.product'].create({
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.storage_box = cls.env['product.product'].create({
'name': 'Storage Box',
'standard_price': 70.0,
'list_price': 79.0,
'website_published': True,
})
self.product_attribute_1 = self.env['product.attribute'].create({
cls.product_attribute_legs = cls.env['product.attribute'].create({
'name': 'Legs',
'sequence': 10,
'value_ids': [
Command.create({
'name': 'Steel',
'sequence': 1,
}),
Command.create({
'name': 'Aluminium',
'sequence': 2,
}),
],
})
product_attribute_value_1 = self.env['product.attribute.value'].create({
'name': 'Steel',
'attribute_id': self.product_attribute_1.id,
'sequence': 1,
})
product_attribute_value_2 = self.env['product.attribute.value'].create({
'name': 'Aluminium',
'attribute_id': self.product_attribute_1.id,
'sequence': 2,
})
self.product_product_11_product_template = self.env['product.template'].create({
cls.conference_chair = cls.env['product.template'].create({
'name': 'Conference Chair',
'list_price': 16.50,
'website_published': True,
'sale_ok': True,
'accessory_product_ids': [(4, product_product_7.id)],
})
self.env['product.template.attribute.line'].create({
'product_tmpl_id': self.product_product_11_product_template.id,
'attribute_id': self.product_attribute_1.id,
'value_ids': [(4, product_attribute_value_1.id), (4, product_attribute_value_2.id)],
'accessory_product_ids': [Command.link(cls.storage_box.id)],
'attribute_line_ids': [
Command.create({
'attribute_id': cls.product_attribute_legs.id,
'value_ids': [Command.set(cls.product_attribute_legs.value_ids.ids)],
})
],
})
self.product_product_1_product_template = self.env['product.template'].create({
cls.chair_floor_protection = cls.env['product.template'].create({
'name': 'Chair floor protection',
'list_price': 12.0,
})
# Crappy hack: But otherwise the "Proceed To Checkout" modal button won't be displayed
if 'optional_product_ids' in self.env['product.template']:
self.product_product_11_product_template.optional_product_ids = [(6, 0, self.product_product_1_product_template.ids)]
if 'optional_product_ids' in cls.env['product.template']:
cls.conference_chair.optional_product_ids = [Command.set(cls.chair_floor_protection.ids)]
self.env['account.journal'].create({'name': 'Cash - Test', 'type': 'cash', 'code': 'CASH - Test'})
# Avoid Shipping/Billing address page
(self.env.ref('base.partner_admin') + self.partner_demo).write({
'street': '215 Vine St',
'city': 'Scranton',
'zip': '18503',
'country_id': self.env.ref('base.us').id,
'state_id': self.env.ref('base.state_us_39').id,
'phone': '+1 555-555-5555',
'email': 'admin@yourcompany.example.com',
cls.env['account.journal'].create({
'name': 'Cash - Test',
'type': 'cash',
'code': 'CASH - Test',
})
# Avoid Shipping/Billing address page
cls.env.ref('base.partner_admin').write(cls.dummy_partner_address_values)
cls.partner_website_user.write(cls.dummy_partner_address_values)
if cls.env['ir.module.module']._get('payment_custom').state == 'installed':
transfer_provider = cls.env.ref('payment.payment_provider_transfer')
transfer_provider.write({
'state': 'enabled',
'is_published': True,
})
transfer_provider._transfer_ensure_pending_msg_is_set()
def test_01_admin_shop_tour(self):
self.start_tour(self.env['website'].get_client_action_url('/shop'), 'shop', login='admin')
self.start_tour(self.env['website'].get_client_action_url('/shop'), 'test_01_admin_shop_tour', login='admin')
def test_01_cart_update_check(self):
self.start_tour('/', 'shop_update_cart', login='admin')
def test_02_admin_checkout(self):
if self.env['ir.module.module']._get('payment_custom').state != 'installed':
self.skipTest("Transfer provider is not installed")
transfer_provider = self.env.ref('payment.payment_provider_transfer')
transfer_provider.write({
'state': 'enabled',
'is_published': True,
})
transfer_provider._transfer_ensure_pending_msg_is_set()
self.start_tour("/", 'shop_buy_product', login="admin")
def test_03_demo_checkout(self):
self.partner_demo.write(self.dummy_partner_address_values)
if self.env['ir.module.module']._get('payment_custom').state != 'installed':
self.skipTest("Transfer provider is not installed")
transfer_provider = self.env.ref('payment.payment_provider_transfer')
transfer_provider.write({
'state': 'enabled',
'is_published': True,
})
transfer_provider._transfer_ensure_pending_msg_is_set()
self.start_tour("/", 'shop_buy_product', login="demo")
def test_04_admin_website_sale_tour(self):
if self.env['ir.module.module']._get('payment_custom').state != 'installed':
self.skipTest("Transfer provider is not installed")
self.env.ref('payment.payment_provider_transfer').write({
'state': 'enabled',
'is_published': True,
})
self.env.company.country_id = self.env.ref('base.us')
self.env.company.country_id = self.country_us
tax_group = self.env['account.tax.group'].create({'name': 'Tax 15%'})
tax = self.env['account.tax'].create({
'name': 'Tax 15%',
@ -120,7 +114,6 @@ class TestUi(HttpCaseWithUserDemo):
'name': 'Storage Box Test',
'standard_price': 70.0,
'list_price': 79.0,
'categ_id': self.env.ref('product.product_category_all').id,
'website_published': True,
'invoice_policy': 'delivery',
})
@ -128,12 +121,14 @@ class TestUi(HttpCaseWithUserDemo):
self.env['res.config.settings'].create({
'auth_signup_uninvited': 'b2c',
'show_line_subtotals_tax_selection': 'tax_excluded',
'group_show_line_subtotals_tax_excluded': True,
'group_show_line_subtotals_tax_included': False,
}).execute()
self.start_tour("/", 'website_sale_tour_1')
self.start_tour(self.env['website'].get_client_action_url('/shop/cart'), 'website_sale_tour_backend', login='admin')
self.start_tour(
self.env['website'].get_client_action_url('/shop/cart'),
'website_sale_tour_backend',
login='admin'
)
self.start_tour("/", 'website_sale_tour_2', login="admin")
def test_05_google_analytics_tracking(self):
@ -155,7 +150,7 @@ class TestUi(HttpCaseWithUserDemo):
'name': 'Colored T-Shirt',
'standard_price': 500,
'list_price': 750,
'detailed_type': 'consu',
'type': 'consu',
'website_published': True,
'attribute_line_ids': [
Command.create({
@ -170,339 +165,59 @@ class TestUi(HttpCaseWithUserDemo):
self.env['product.template'].create({
'name': 'Basic Shirt',
'standard_price': 500,
'detailed_type': 'consu',
'type': 'consu',
'website_published': True
})
self.start_tour("/shop", 'google_analytics_add_to_cart')
def test_06_public_user_shop_repair(self):
""" Public user purchasing repair service products in website shop. """
if self.env['ir.module.module']._get('repair').state != 'installed':
self.skipTest("Repair is not installed")
@odoo.tests.tagged('post_install', '-at_install')
class TestWebsiteSaleCheckoutAddress(TransactionCaseWithUserDemo, HttpCaseWithUserPortal):
''' The goal of this method class is to test the address management on
the checkout (new/edit billing/shipping, company_id, website_id..).
'''
def setUp(self):
super(TestWebsiteSaleCheckoutAddress, self).setUp()
self.partner_demo.company_id = self.env.ref('base.main_company')
self.website = self.env.ref('website.default_website')
self.country_id = self.env.ref('base.be').id
self.WebsiteSaleController = WebsiteSale()
self.default_address_values = {
'name': 'a res.partner address', 'email': 'email@email.email', 'street': 'ooo',
'city': 'ooo', 'zip': '1200', 'country_id': self.country_id, 'submitted': 1,
}
def _create_so(self, partner_id=None, company_id=None):
values = {
'partner_id': partner_id,
'website_id': self.website.id,
'order_line': [(0, 0, {
'product_id': self.env['product.product'].create({
'name': 'Product A',
'list_price': 100,
'website_published': True,
'sale_ok': True}).id,
'name': 'Product A',
})]
}
if company_id:
values['company_id'] = company_id
return self.env['sale.order'].create(values)
def _get_last_address(self, partner):
''' Useful to retrieve the last created shipping address '''
return partner.child_ids.sorted('id', reverse=True)[0]
# TEST WEBSITE
def test_01_create_shipping_address_specific_user_account(self):
''' Ensure `website_id` is correctly set (specific_user_account) '''
p = self.env.user.partner_id
so = self._create_so(p.id)
with MockRequest(self.env, website=self.website, sale_order_id=so.id) as req:
req.httprequest.method = "POST"
self.WebsiteSaleController.address(**self.default_address_values)
self.assertFalse(self._get_last_address(p).website_id, "New shipping address should not have a website set on it (no specific_user_account).")
self.website.specific_user_account = True
self.WebsiteSaleController.address(**self.default_address_values)
self.assertEqual(self._get_last_address(p).website_id, self.website, "New shipping address should have a website set on it (specific_user_account).")
# TEST COMPANY
def _setUp_multicompany_env(self):
''' Have 2 companies A & B.
Have 1 website 1 which company is B
Have admin on company A
'''
self.company_a = self.env['res.company'].create({
'name': 'Company A',
})
self.company_b = self.env['res.company'].create({
'name': 'Company B',
})
self.company_c = self.env['res.company'].create({
'name': 'Company C',
})
self.website.company_id = self.company_b
self.env.user.company_id = self.company_a
self.demo_user = self.user_demo
self.demo_user.company_ids += self.company_c
self.demo_user.company_id = self.company_c
self.demo_partner = self.demo_user.partner_id
self.portal_user = self.user_portal
self.portal_partner = self.portal_user.partner_id
def test_02_demo_address_and_company(self):
''' This test ensure that the company_id of the address (partner) is
correctly set and also, is not wrongly changed.
eg: new shipping should use the company of the website and not the
one from the admin, and editing a billing should not change its
company.
'''
self._setUp_multicompany_env()
so = self._create_so(self.demo_partner.id)
env = api.Environment(self.env.cr, self.demo_user.id, {})
# change also website env for `sale_get_order` to not change order partner_id
with MockRequest(env, website=self.website.with_env(env), sale_order_id=so.id) as req:
req.httprequest.method = "POST"
# 1. Logged in user, new shipping
self.WebsiteSaleController.address(**self.default_address_values)
new_shipping = self._get_last_address(self.demo_partner)
self.assertTrue(new_shipping.company_id != self.env.user.company_id, "Logged in user new shipping should not get the company of the sudo() neither the one from it's partner..")
self.assertEqual(new_shipping.company_id, self.website.company_id, ".. but the one from the website.")
# 2. Logged in user/internal user, should not edit name or email address of billing
self.default_address_values['partner_id'] = self.demo_partner.id
self.WebsiteSaleController.address(**self.default_address_values)
self.assertEqual(self.demo_partner.company_id, self.company_c, "Logged in user edited billing (the partner itself) should not get its company modified.")
self.assertNotEqual(self.demo_partner.name, self.default_address_values['name'], "Employee cannot change their name during the checkout process.")
self.assertNotEqual(self.demo_partner.email, self.default_address_values['email'], "Employee cannot change their email during the checkout process.")
def test_03_public_user_address_and_company(self):
''' Same as test_02 but with public user '''
self._setUp_multicompany_env()
so = self._create_so(self.website.user_id.partner_id.id)
env = api.Environment(self.env.cr, self.website.user_id.id, {})
# change also website env for `sale_get_order` to not change order partner_id
with MockRequest(env, website=self.website.with_env(env), sale_order_id=so.id) as req:
req.httprequest.method = "POST"
# 1. Public user, new billing
self.default_address_values['partner_id'] = -1
self.WebsiteSaleController.address(**self.default_address_values)
new_partner = so.partner_id
self.assertNotEqual(new_partner, self.website.user_id.partner_id, "New billing should have created a new partner and assign it on the SO")
self.assertEqual(new_partner.company_id, self.website.company_id, "The new partner should get the company of the website")
# 2. Public user, edit billing
self.default_address_values['partner_id'] = new_partner.id
self.WebsiteSaleController.address(**self.default_address_values)
self.assertEqual(new_partner.company_id, self.website.company_id, "Public user edited billing (the partner itself) should not get its company modified.")
def test_04_apply_empty_pl(self):
''' Ensure empty pl code reset the applied pl '''
so = self._create_so(self.env.user.partner_id.id)
eur_pl = self.env['product.pricelist'].create({
'name': 'EUR_test',
'website_id': self.website.id,
'code': 'EUR_test',
})
with MockRequest(self.env, website=self.website, sale_order_id=so.id):
self.WebsiteSaleController.pricelist('EUR_test')
self.assertEqual(so.pricelist_id, eur_pl, "Ensure EUR_test is applied")
self.WebsiteSaleController.pricelist('')
self.assertNotEqual(so.pricelist_id, eur_pl, "Pricelist should be removed when sending an empty pl code")
def test_04_pl_reset_on_login(self):
"""Check that after login, the SO pricelist is correctly recomputed."""
test_user = self.env['res.users'].create({
'name': 'Toto',
'login': 'long_enough_password',
'password': 'long_enough_password',
})
eur_pl = self.env['product.pricelist'].create({
'name': 'EUR_test',
'website_id': self.website.id,
'code': 'EUR_test',
})
test_user.partner_id.property_product_pricelist = eur_pl
public_user_env = self.env(user=self.website.user_id)
so = self._create_so(public_user_env.user.partner_id.id)
with MockRequest(self.env, website=self.website, sale_order_id=so.id, website_sale_current_pl=so.pricelist_id.id):
order = self.website.sale_get_order()
pl = order.pricelist_id
self.assertNotEqual(pl, eur_pl)
order_b = self.website.with_user(test_user).sale_get_order()
self.assertEqual(order, order_b)
self.assertEqual(order_b.pricelist_id, eur_pl)
# TEST WEBSITE & MULTI COMPANY
def test_05_create_so_with_website_and_multi_company(self):
''' This test ensure that the company_id of the website set on the order
is the same as the env company or the one set on the order.
'''
self._setUp_multicompany_env()
# No company on the SO
so = self._create_so(self.demo_partner.id)
self.assertEqual(so.company_id, self.website.company_id)
# Same company on the SO and the env user company but no website
with self.assertRaises(ValueError, msg="Should not be able to create SO with company different than the website company"):
self._create_so(self.demo_partner.id, self.company_a.id)
# Same company on the SO and the website company
so = self._create_so(self.demo_partner.id, self.company_b.id)
self.assertEqual(so.company_id, self.website.company_id)
# Different company on the SO and the env user company
with self.assertRaises(ValueError, msg="Should not be able to create SO with company different than the website company"):
self._create_so(self.demo_partner.id, self.company_c.id)
def test_06_portal_user_address_and_company(self):
''' Same as test_03 but with portal user '''
self._setUp_multicompany_env()
so = self._create_so(self.portal_partner.id)
self.env['sale.order'].create({
'partner_id': self.partner_portal.id,
'state': 'sent',
})
env = api.Environment(self.env.cr, self.portal_user.id, {})
# change also website env for `sale_get_order` to not change order partner_id
with MockRequest(env, website=self.website.with_env(env), sale_order_id=so.id) as req:
req.httprequest.method = "POST"
# 1. Portal user, new shipping, same with the log in user
self.WebsiteSaleController.address(**self.default_address_values)
new_shipping = self._get_last_address(self.portal_partner)
self.assertTrue(new_shipping.company_id != self.env.user.company_id, "Portal user new shipping should not get the company of the sudo() neither the one from it's partner..")
self.assertEqual(new_shipping.company_id, self.website.company_id, ".. but the one from the website.")
# 2. Portal user, edit billing
self.default_address_values['partner_id'] = self.portal_partner.id
self.WebsiteSaleController.address(**self.default_address_values)
# Name cannot be changed if there are issued invoices
self.assertNotEqual(self.portal_partner.name, self.default_address_values['name'], "Portal User should not be able to change the name if they have invoices under their name.")
def test_07_change_fiscal_position(self):
"""
Check that the sale order is updated when you change fiscal position.
Change fiscal position by modifying address during checkout process.
"""
self.env.company.country_id = self.env.ref('base.us')
partner = self.env['res.partner'].create({'name': 'test'})
be_address_POST, nl_address_POST = [
{
'name': 'Test name', 'email': 'test@email.com', 'street': 'test',
'city': 'test', 'zip': '3000', 'country_id': self.env.ref('base.be').id, 'submitted': 1,
'partner_id': partner.id,
'callback': '/shop/checkout',
},
{
'name': 'Test name', 'email': 'test@email.com', 'street': 'test',
'city': 'test', 'zip': '3000', 'country_id': self.env.ref('base.nl').id, 'submitted': 1,
'partner_id': partner.id,
'callback': '/shop/checkout',
},
]
tax_10_incl, tax_20_excl, tax_15_incl = self.env['account.tax'].create([
{'name': 'Tax 10% incl', 'amount': 10, 'price_include': True},
{'name': 'Tax 20% excl', 'amount': 20, 'price_include': False},
{'name': 'Tax 15% incl', 'amount': 15, 'price_include': True},
])
self.env['account.fiscal.position'].create([
{
'sequence': 1,
'name': 'BE',
'auto_apply': True,
'country_id': self.env.ref('base.be').id,
'tax_ids': [Command.create({'tax_src_id': tax_10_incl.id, 'tax_dest_id': tax_20_excl.id})],
},
{
'sequence': 2,
'name': 'NL',
'auto_apply': True,
'country_id': self.env.ref('base.nl').id,
'tax_ids': [Command.create({'tax_src_id': tax_10_incl.id, 'tax_dest_id': tax_15_incl.id})],
},
])
product = self.env['product.product'].create({
'name': 'Product test',
'list_price': 100,
'website_published': True,
self.env['product.template'].create({
'name': 'Test Repair Service',
'type': 'service',
'service_tracking': 'repair',
'sale_ok': True,
'taxes_id': [tax_10_incl.id]
'is_published': True,
})
so = self.env['sale.order'].create({
'partner_id': partner.id,
'website_id': self.website.id,
'order_line': [Command.create({
'product_id': product.id,
'name': 'Product test',
})]
self.start_tour("/", 'shop_repair_product', login=None)
def test_checkout_with_rewrite(self):
# check that checkout page can be open with step rewritten
self.env['website.rewrite'].create({
'name': 'Test Address Rename',
'redirect_type': '308',
'url_from': '/shop/address',
'url_to': '/test/address',
})
self.env['website.rewrite'].create({
'name': 'Test Checkout Rename',
'redirect_type': '308',
'url_from': '/shop/checkout',
'url_to': '/test/checkout',
})
self._create_so(partner_id=self.user_demo.partner_id.id)
self.authenticate('demo', 'demo')
response = self.url_open('/shop/address')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.url[-13:], '/test/address')
self.assertEqual(
[so.amount_untaxed, so.amount_tax, so.amount_total],
[90.91, 9.09, 100.0]
)
# check that navigation (next and previous checkout steps) are correct
allowed_steps_domain = self.website._get_allowed_steps_domain()
checkout_step = self.env.ref('website_sale.checkout_step_delivery')
previous_step = checkout_step._get_previous_checkout_step(allowed_steps_domain)
next_step = checkout_step._get_next_checkout_step(allowed_steps_domain)
root = lxml.html.fromstring(response.content)
self.assertEqual(len(root.xpath(f'//a[@href="{previous_step.step_href}"]//span[text()="{previous_step.back_button_label}"]')), 2)
self.assertEqual(len(root.xpath(f'//a[@name="website_sale_main_button"][not(@href)]//span[text()="{next_step.main_button_label}"]')), 2)
env = api.Environment(self.env.cr, self.website.user_id.id, {})
with MockRequest(self.env, website=self.website.with_env(env), sale_order_id=so.id) as req:
req.httprequest.method = "POST"
self.WebsiteSaleController.address(**be_address_POST)
self.assertEqual(
[so.amount_untaxed, so.amount_tax, so.amount_total],
[90.91, 18.18, 109.09] # (100 : (1 + 10%)) * (1 + 20%) = 109.09
)
self.WebsiteSaleController.address(**nl_address_POST)
self.assertEqual(
[so.amount_untaxed, so.amount_tax, so.amount_total],
[90.91, 13.64, 104.55] # (100 : (1 + 10%)) * (1 + 15%) = 104.55
)
def test_08_payment_term_when_address_change(self):
''' This test ensures that the payment term set when triggering
`onchange_partner_id` by changing the address of a website sale
order is computed by `sale_get_payment_term`.
'''
self._setUp_multicompany_env()
product_id = self.env['product.product'].create({
'name': 'Product A',
'list_price': 100,
'website_published': True,
'sale_ok': True}).id
env = api.Environment(self.env.cr, self.portal_user.id, {})
with MockRequest(env, website=self.website.with_env(env).with_context(website_id=self.website.id)) as req:
req.httprequest.method = "POST"
self.WebsiteSaleController.cart_update(product_id)
so = self.portal_user.sale_order_ids[0]
self.assertTrue(so.payment_term_id, "A payment term should be set by default on the sale order")
self.default_address_values['partner_id'] = self.portal_partner.id
self.default_address_values['name'] = self.portal_partner.name
self.WebsiteSaleController.address(**self.default_address_values)
self.assertTrue(so.payment_term_id, "A payment term should still be set on the sale order")
so.website_id = False
self.WebsiteSaleController.address(**self.default_address_values)
self.assertFalse(so.payment_term_id, "The website default payment term should not be set on a sale order not coming from the website")
def test_update_same_address_billing_shipping_edit(self):
''' Phone field should be required when updating an adress for billing and shipping '''
self.env['product.product'].create({
'name': 'Office Chair Black TEST',
'list_price': 12.50,
'is_published': True,
})
self.start_tour("/shop", 'update_billing_shipping_address', login="website_user")