mirror of
https://github.com/bringout/oca-ocb-sale.git
synced 2026-04-26 11:32:07 +02:00
535 lines
24 KiB
Python
535 lines
24 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from unittest.mock import Mock, patch
|
|
|
|
from odoo.http import root
|
|
from odoo.tests import HttpCase, tagged
|
|
from odoo.tools import urls
|
|
|
|
from odoo.addons.payment import utils as payment_utils
|
|
from odoo.addons.website_sale.controllers.delivery import Delivery as WebsiteSaleDeliveryController
|
|
from odoo.addons.website_sale.controllers.main import WebsiteSale
|
|
from odoo.addons.website_sale.controllers.cart import Cart
|
|
from odoo.addons.website_sale.tests.common import MockRequest, WebsiteSaleCommon
|
|
|
|
|
|
@tagged('post_install', '-at_install')
|
|
class TestWebsiteSaleExpressCheckoutFlows(WebsiteSaleCommon, HttpCase):
|
|
""" The goal of this method class is to test the address management on
|
|
express checkout.
|
|
"""
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
cls.country_id = cls.country_be.id
|
|
cls.sale_order = cls.cart
|
|
cls.sale_order.partner_id = cls.public_partner.id
|
|
cls.express_checkout_billing_values = {
|
|
'name': 'Express Checkout Partner',
|
|
'email': 'express@check.out',
|
|
'phone': '0000000000',
|
|
'street': 'ooo',
|
|
'street2': 'ppp',
|
|
'city': 'ooo',
|
|
'zip': '1200',
|
|
'country': "US", # United States
|
|
'state': "CA", # California
|
|
}
|
|
cls.express_checkout_shipping_values = {
|
|
'name': "Express Checkout Shipping Partner",
|
|
'email': "express_shipping@check.out",
|
|
'phone': "1111111111",
|
|
'street': "ooo shipping",
|
|
'street2': "ppp shipping",
|
|
'city': "ooo shipping",
|
|
'zip': "25781",
|
|
'country': "US", # United States
|
|
'state': "WA", # Washington
|
|
}
|
|
cls.express_checkout_anonymized_shipping_values = {
|
|
'city': "ooo shipping",
|
|
'zip': "6155",
|
|
'country': "AU", # Australia
|
|
'state': "WA", # Western Australia
|
|
}
|
|
cls.express_checkout_anonymized_shipping_values_2 = {
|
|
'city': "ooo shipping 2",
|
|
'zip': "11519",
|
|
'country': "ES", # Spain
|
|
'state': "CA", # Cádiz
|
|
}
|
|
|
|
cls.user_demo = cls._create_new_internal_user(**cls.dummy_partner_address_values)
|
|
|
|
cls.express_checkout_demo_shipping_values = {
|
|
'name': cls.user_demo.partner_id.name,
|
|
'email': cls.user_demo.partner_id.email,
|
|
'phone': cls.user_demo.partner_id.phone,
|
|
'street': cls.user_demo.partner_id.street,
|
|
'street2': cls.user_demo.partner_id.street2,
|
|
'city': cls.user_demo.partner_id.city,
|
|
'zip': cls.user_demo.partner_id.zip,
|
|
'country': cls.user_demo.partner_id.country_id.code,
|
|
'state': cls.user_demo.partner_id.state_id.code,
|
|
}
|
|
cls.express_checkout_anonymized_demo_shipping_values = {
|
|
'city': cls.user_demo.partner_id.city,
|
|
'zip': cls.user_demo.partner_id.zip,
|
|
'country': cls.user_demo.partner_id.country_id.code,
|
|
'state': cls.user_demo.partner_id.state_id.code,
|
|
}
|
|
cls.express_checkout_demo_shipping_values_2 = {
|
|
'name': "Express Checkout Shipping Partner",
|
|
'email': "express_shipping@check.out",
|
|
'phone': "1111111111",
|
|
'street': "ooo shipping",
|
|
'street2': "ppp shipping",
|
|
'city': cls.user_demo.partner_id.city,
|
|
'zip': cls.user_demo.partner_id.zip,
|
|
'country': cls.user_demo.partner_id.country_id.code,
|
|
'state': cls.user_demo.partner_id.state_id.code,
|
|
}
|
|
cls.rate_shipment_result = {
|
|
'success': True,
|
|
'price': 5.0,
|
|
'warning_message': "",
|
|
}
|
|
|
|
def assertPartnerShippingValues(self, partner, shipping_values):
|
|
for key, expected in shipping_values.items():
|
|
if key in ('state', 'country'):
|
|
value = partner[f'{key}_id'].code
|
|
else:
|
|
value = partner[key]
|
|
self.assertEqual(value, expected, "Shipping value should match")
|
|
if partner.state_id:
|
|
self.assertEqual(
|
|
partner.state_id.country_id,
|
|
partner.country_id,
|
|
"Partner's state should be within partner's country",
|
|
)
|
|
|
|
def test_express_checkout_takes_order_amount_without_delivery(self):
|
|
"""Test that the amount to pay does not include the delivery costs in express checkout."""
|
|
amount_without_delivery = payment_utils.to_minor_currency_units(
|
|
self.cart.amount_total, self.cart.currency_id
|
|
)
|
|
self.carrier.fixed_price = 20
|
|
self.cart.set_delivery_line(self.carrier, self.carrier.fixed_price)
|
|
with MockRequest(self.env, sale_order_id=self.cart.id, website=self.website):
|
|
payment_values = Cart()._get_express_shop_payment_values(self.cart)
|
|
|
|
self.assertEqual(payment_values['minor_amount'], amount_without_delivery)
|
|
|
|
def test_express_checkout_public_user(self):
|
|
""" Test that when using express checkout as a public user, a new partner is created. """
|
|
session = self.authenticate(None, None)
|
|
session['sale_order_id'] = self.sale_order.id
|
|
root.session_store.save(session)
|
|
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(), WebsiteSale._express_checkout_route
|
|
), params={
|
|
'billing_address': dict(self.express_checkout_billing_values)
|
|
}
|
|
)
|
|
|
|
new_partner = self.sale_order.partner_id
|
|
self.assertNotEqual(new_partner, self.website.user_id.partner_id)
|
|
self.assertPartnerShippingValues(
|
|
new_partner,
|
|
self.express_checkout_billing_values,
|
|
)
|
|
|
|
def test_express_checkout_registered_user(self):
|
|
""" Test that when you use express checkout as a registered user and the address sent by the
|
|
express checkout form exactly matches the one registered in odoo, we do not create a new
|
|
partner and reuse the existing one.
|
|
"""
|
|
self.sale_order.partner_id = self.user_demo.partner_id.id
|
|
session = self.authenticate(self.user_demo.login, self.user_demo.login)
|
|
session['sale_order_id'] = self.sale_order.id
|
|
root.session_store.save(session)
|
|
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(), WebsiteSale._express_checkout_route
|
|
), params={
|
|
'billing_address': {
|
|
'name': self.user_demo.partner_id.name,
|
|
'email': self.user_demo.partner_id.email,
|
|
'phone': self.user_demo.partner_id.phone,
|
|
'street': self.user_demo.partner_id.street,
|
|
'street2': self.user_demo.partner_id.street2,
|
|
'city': self.user_demo.partner_id.city,
|
|
'zip': self.user_demo.partner_id.zip,
|
|
'country': self.user_demo.partner_id.country_id.code,
|
|
'state': self.user_demo.partner_id.state_id.code,
|
|
}
|
|
}
|
|
)
|
|
|
|
self.assertEqual(self.sale_order.partner_id.id, self.user_demo.partner_id.id)
|
|
self.assertEqual(self.sale_order.partner_invoice_id.id, self.user_demo.partner_id.id)
|
|
|
|
def test_express_checkout_registered_user_existing_address(self):
|
|
""" Test that when you use the express checkout as a registered user and the address sent by
|
|
the express checkout form exactly matches to one of the addresses linked to this user in
|
|
odoo, we do not create a new partner and reuse the existing one.
|
|
"""
|
|
# Create a child partner for the demo partner
|
|
child_partner_address = dict(self.express_checkout_billing_values)
|
|
child_partner_country = self.env['res.country'].search([
|
|
('code', '=', child_partner_address.pop('country')),
|
|
], limit=1)
|
|
child_partner_state = self.env['res.country.state'].search([
|
|
('code', '=', child_partner_address.pop('state')),
|
|
('country_id', '=', child_partner_country.id),
|
|
], limit=1)
|
|
child_partner = self.env['res.partner'].create(dict(
|
|
**child_partner_address,
|
|
parent_id=self.user_demo.partner_id.id,
|
|
type='invoice',
|
|
country_id=child_partner_country.id,
|
|
state_id=child_partner_state.id,
|
|
))
|
|
|
|
self.sale_order.partner_id = self.user_demo.partner_id.id
|
|
session = self.authenticate(self.user_demo.login, self.user_demo.login)
|
|
session['sale_order_id'] = self.sale_order.id
|
|
root.session_store.save(session)
|
|
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(), WebsiteSale._express_checkout_route
|
|
), params={
|
|
'billing_address': dict(self.express_checkout_billing_values)
|
|
}
|
|
)
|
|
|
|
self.assertEqual(self.sale_order.partner_id.id, self.user_demo.partner_id.id)
|
|
self.assertEqual(self.sale_order.partner_invoice_id.id, child_partner.id)
|
|
|
|
def test_express_checkout_registered_user_new_address(self):
|
|
""" Test that when you use the express checkout as a registered user and the address sent by
|
|
the express checkout form doesn't match to one of the addresses linked to this user in
|
|
odoo, we create a new partner.
|
|
"""
|
|
self.sale_order.partner_id = self.user_demo.partner_id.id
|
|
session = self.authenticate(self.user_demo.login, self.user_demo.login)
|
|
session['sale_order_id'] = self.sale_order.id
|
|
root.session_store.save(session)
|
|
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(), WebsiteSale._express_checkout_route
|
|
), params={
|
|
'billing_address': dict(self.express_checkout_billing_values)
|
|
}
|
|
)
|
|
|
|
self.assertEqual(self.sale_order.partner_id.id, self.user_demo.partner_id.id)
|
|
new_partner = self.sale_order.partner_invoice_id
|
|
self.assertNotEqual(new_partner, self.website.user_id.partner_id)
|
|
self.assertPartnerShippingValues(
|
|
new_partner,
|
|
self.express_checkout_billing_values,
|
|
)
|
|
|
|
def test_express_checkout_public_user_shipping_address_change(self):
|
|
""" Test that when using express checkout as a public user and selecting a shipping address,
|
|
a new partner is created if the partner of the SO is the public partner.
|
|
"""
|
|
session = self.authenticate(None, None)
|
|
session['sale_order_id'] = self.sale_order.id
|
|
root.session_store.save(session)
|
|
with patch(
|
|
'odoo.addons.delivery.models.delivery_carrier.DeliveryCarrier.rate_shipment',
|
|
return_value=self.rate_shipment_result
|
|
):
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(),
|
|
WebsiteSaleDeliveryController._express_checkout_delivery_route,
|
|
),
|
|
params={
|
|
'partial_delivery_address': dict(
|
|
self.express_checkout_anonymized_shipping_values,
|
|
),
|
|
},
|
|
)
|
|
new_partner = self.sale_order.partner_shipping_id
|
|
self.assertNotEqual(new_partner, self.website.user_id.partner_id)
|
|
self.assertTrue(new_partner.name.endswith(self.sale_order.name))
|
|
self.assertPartnerShippingValues(
|
|
new_partner,
|
|
self.express_checkout_anonymized_shipping_values,
|
|
)
|
|
|
|
def test_express_checkout_public_user_shipping_address_change_twice(self):
|
|
""" Test that when using express checkout as a public user and selecting a shipping address
|
|
more than once, a new partner is created if the partner of the SO is the public partner
|
|
(only creates one new partner that is updated).
|
|
"""
|
|
session = self.authenticate(None, None)
|
|
session['sale_order_id'] = self.sale_order.id
|
|
root.session_store.save(session)
|
|
with patch(
|
|
'odoo.addons.delivery.models.delivery_carrier.DeliveryCarrier.rate_shipment',
|
|
return_value=self.rate_shipment_result
|
|
):
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(),
|
|
WebsiteSaleDeliveryController._express_checkout_delivery_route,
|
|
),
|
|
params={
|
|
'partial_delivery_address': dict(
|
|
self.express_checkout_anonymized_shipping_values,
|
|
),
|
|
},
|
|
)
|
|
new_partner = self.sale_order.partner_shipping_id
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(),
|
|
WebsiteSaleDeliveryController._express_checkout_delivery_route,
|
|
),
|
|
params={
|
|
'partial_delivery_address': dict(
|
|
self.express_checkout_anonymized_shipping_values_2,
|
|
),
|
|
},
|
|
)
|
|
self.assertEqual(new_partner.id, self.sale_order.partner_shipping_id.id)
|
|
self.assertPartnerShippingValues(
|
|
new_partner,
|
|
self.express_checkout_anonymized_shipping_values_2,
|
|
)
|
|
|
|
def test_express_checkout_registered_user_exisiting_shipping_address_change(self):
|
|
""" Test that when using express checkout as a registered user and selecting an exisiting
|
|
shipping address, the existing partner (the one of the SO) is reused.
|
|
"""
|
|
self.sale_order.partner_id = self.user_demo.partner_id.id
|
|
session = self.authenticate(self.user_demo.login, self.user_demo.login)
|
|
session['sale_order_id'] = self.sale_order.id
|
|
root.session_store.save(session)
|
|
with patch(
|
|
'odoo.addons.delivery.models.delivery_carrier.DeliveryCarrier.rate_shipment',
|
|
return_value=self.rate_shipment_result
|
|
):
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(),
|
|
WebsiteSaleDeliveryController._express_checkout_delivery_route,
|
|
),
|
|
params={
|
|
'partial_delivery_address': dict(
|
|
self.express_checkout_anonymized_shipping_values,
|
|
),
|
|
},
|
|
)
|
|
self.assertEqual(self.sale_order.partner_id.id, self.user_demo.partner_id.id)
|
|
|
|
def test_express_checkout_registered_user_new_shipping_address_change(self):
|
|
""" Test that when using express checkout as a registered user and selecting a new shipping
|
|
address, a new partner is created if the partner of the SO or his children are different
|
|
from the delivery information received.
|
|
"""
|
|
self.sale_order.partner_id = self.user_demo.partner_id.id
|
|
session = self.authenticate(self.user_demo.login, self.user_demo.login)
|
|
session['sale_order_id'] = self.sale_order.id
|
|
root.session_store.save(session)
|
|
with patch(
|
|
'odoo.addons.delivery.models.delivery_carrier.DeliveryCarrier.rate_shipment',
|
|
return_value=self.rate_shipment_result
|
|
):
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(),
|
|
WebsiteSaleDeliveryController._express_checkout_delivery_route,
|
|
),
|
|
params={
|
|
'partial_delivery_address': dict(
|
|
self.express_checkout_anonymized_shipping_values,
|
|
),
|
|
},
|
|
)
|
|
new_partner = self.sale_order.partner_shipping_id
|
|
self.assertEqual(self.sale_order.partner_id.id, self.user_demo.partner_id.id)
|
|
self.assertNotEqual(new_partner.id, self.user_demo.partner_id.id)
|
|
self.assertTrue(new_partner.name.endswith(self.sale_order.name))
|
|
self.assertPartnerShippingValues(
|
|
new_partner,
|
|
self.express_checkout_anonymized_shipping_values,
|
|
)
|
|
|
|
def test_express_checkout_registered_user_new_shipping_address_change_twice(self):
|
|
""" Test that when using express checkout as a registered user and selecting a new
|
|
shipping address more than once, a new partner is created if the partner of the SO is
|
|
the public partner (only creates one new partner that is updated).
|
|
"""
|
|
self.sale_order.partner_id = self.user_demo.partner_id.id
|
|
session = self.authenticate(self.user_demo.login, self.user_demo.login)
|
|
session['sale_order_id'] = self.sale_order.id
|
|
root.session_store.save(session)
|
|
with patch(
|
|
'odoo.addons.delivery.models.delivery_carrier.DeliveryCarrier.rate_shipment',
|
|
return_value=self.rate_shipment_result
|
|
):
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(),
|
|
WebsiteSaleDeliveryController._express_checkout_delivery_route,
|
|
),
|
|
params={
|
|
'partial_delivery_address': dict(
|
|
self.express_checkout_anonymized_shipping_values,
|
|
),
|
|
},
|
|
)
|
|
new_partner = self.sale_order.partner_shipping_id
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(),
|
|
WebsiteSaleDeliveryController._express_checkout_delivery_route,
|
|
),
|
|
params={
|
|
'partial_delivery_address': dict(
|
|
self.express_checkout_anonymized_shipping_values_2,
|
|
),
|
|
},
|
|
)
|
|
self.assertEqual(new_partner.id, self.sale_order.partner_shipping_id.id)
|
|
self.assertPartnerShippingValues(
|
|
new_partner,
|
|
self.express_checkout_anonymized_shipping_values_2
|
|
)
|
|
|
|
def test_express_checkout_partial_delivery_address_context_key(self):
|
|
""" Test that when using express checkout with only partial delivery information,
|
|
`express_checkout_partial_delivery_address` context key is in the context.
|
|
"""
|
|
delivery_carrier_mock = Mock()
|
|
delivery_carrier_mock.rate_shipment = Mock(
|
|
# Since we didn't mock the product ids for the mocked carrier, return an unsuccessful
|
|
# response to skip the part where the product ids are checked on the carrier
|
|
return_value=dict(self.rate_shipment_result, success=False)
|
|
)
|
|
|
|
WebsiteSaleDeliveryController._get_rate(
|
|
delivery_carrier_mock, self.sale_order, is_express_checkout_flow=True
|
|
)
|
|
sale_order = delivery_carrier_mock.rate_shipment.call_args[0][0]
|
|
self.assertTrue(sale_order.env.context.get('express_checkout_partial_delivery_address'))
|
|
|
|
def test_express_checkout_registered_user_with_shipping_option(self):
|
|
""" Test that when you use the express checkout as a registered user and the shipping
|
|
address sent by the express checkout form exactly matches one of the addresses linked
|
|
to this user in Odoo, we do not create a new partner and reuse the existing one.
|
|
"""
|
|
self.sale_order.partner_id = self.user_demo.partner_id.id
|
|
session = self.authenticate(self.user_demo.login, self.user_demo.login)
|
|
session['sale_order_id'] = self.sale_order.id
|
|
root.session_store.save(session)
|
|
with patch(
|
|
'odoo.addons.delivery.models.delivery_carrier.DeliveryCarrier.rate_shipment',
|
|
return_value=self.rate_shipment_result
|
|
):
|
|
shipping_options = self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(),
|
|
WebsiteSaleDeliveryController._express_checkout_delivery_route,
|
|
),
|
|
params={
|
|
'partial_delivery_address': dict(
|
|
self.express_checkout_anonymized_demo_shipping_values,
|
|
),
|
|
},
|
|
)
|
|
self.assertEqual(self.sale_order.partner_id.id, self.user_demo.partner_id.id)
|
|
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(),
|
|
WebsiteSaleDeliveryController._express_checkout_route,
|
|
),
|
|
params={
|
|
'billing_address': dict(self.express_checkout_billing_values),
|
|
'shipping_address': dict(self.express_checkout_demo_shipping_values),
|
|
'shipping_option': shipping_options['delivery_methods'][0],
|
|
},
|
|
)
|
|
self.assertEqual(self.sale_order.partner_id.id, self.user_demo.partner_id.id)
|
|
|
|
def test_express_checkout_registered_user_with_shipping_option_new_address(self):
|
|
""" Test that when you use the express checkout as a registered user and the shipping
|
|
address sent by the express checkout form doesn't exist in Odoo, we create a new
|
|
partner.
|
|
"""
|
|
self.sale_order.partner_id = self.user_demo.partner_id.id
|
|
session = self.authenticate(self.user_demo.login, self.user_demo.login)
|
|
session['sale_order_id'] = self.sale_order.id
|
|
root.session_store.save(session)
|
|
with patch(
|
|
'odoo.addons.delivery.models.delivery_carrier.DeliveryCarrier.rate_shipment',
|
|
return_value=self.rate_shipment_result
|
|
):
|
|
# Won't create a new partner because the partial information are the same as an
|
|
# exisiting partner linked to the SO
|
|
shipping_options = self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(),
|
|
WebsiteSaleDeliveryController._express_checkout_delivery_route,
|
|
),
|
|
params={
|
|
'partial_delivery_address': dict(
|
|
self.express_checkout_anonymized_demo_shipping_values,
|
|
),
|
|
},
|
|
)
|
|
self.assertEqual(self.sale_order.partner_shipping_id, self.user_demo.partner_id)
|
|
|
|
# Will create a new partner because the complete shipping information differs from
|
|
# the partner actually selected
|
|
self.make_jsonrpc_request(
|
|
urls.urljoin(
|
|
self.base_url(),
|
|
WebsiteSaleDeliveryController._express_checkout_route
|
|
),
|
|
params={
|
|
'billing_address': dict(self.express_checkout_billing_values),
|
|
'shipping_address': dict(self.express_checkout_demo_shipping_values_2),
|
|
'shipping_option': shipping_options['delivery_methods'][0],
|
|
},
|
|
)
|
|
self.assertNotEqual(
|
|
self.sale_order.partner_shipping_id.id, self.user_demo.partner_id.id
|
|
)
|
|
self.assertFalse(
|
|
self.sale_order.partner_shipping_id.name.endswith(self.sale_order.name)
|
|
)
|
|
|
|
def test_express_checkout_compute_taxes_returns_amount_without_delivery(self):
|
|
"""
|
|
Test that the /express_checkout/compute_taxes route returns the minor amount
|
|
without delivery costs.
|
|
"""
|
|
websiteSaleDeliveryController = WebsiteSaleDeliveryController()
|
|
|
|
delivery_product = self.env['product.product'].create({'name': 'Delivery'})
|
|
delivery = self.env['delivery.carrier'].create({
|
|
'name': 'Normal Delivery Charges',
|
|
'fixed_price': 10,
|
|
'delivery_type': 'fixed',
|
|
'product_id': delivery_product.id,
|
|
})
|
|
self.sale_order._create_delivery_line(delivery, 10)
|
|
expected_amount = self.sale_order._compute_amount_total_without_delivery()
|
|
|
|
with MockRequest(self.env, website=self.website, sale_order_id=self.sale_order.id):
|
|
minor_amount = websiteSaleDeliveryController.express_checkout_shipping_address_compute_taxes()
|
|
self.assertEqual(minor_amount, expected_amount * 100)
|