237 lines
9.3 KiB
Python
237 lines
9.3 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import logging
|
|
from unittest.mock import patch
|
|
|
|
from lxml import objectify
|
|
|
|
from odoo.fields import Command
|
|
from odoo.tests.common import TransactionCase
|
|
from odoo.tools.misc import hmac as hmac_tool
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class PaymentCommon(TransactionCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
|
|
cls.currency_euro = cls._prepare_currency('EUR')
|
|
cls.currency_usd = cls._prepare_currency('USD')
|
|
|
|
cls.country_belgium = cls.env.ref('base.be')
|
|
cls.country_france = cls.env.ref('base.fr')
|
|
cls.europe = cls.env.ref('base.europe')
|
|
|
|
cls.group_user = cls.env.ref('base.group_user')
|
|
cls.group_portal = cls.env.ref('base.group_portal')
|
|
cls.group_public = cls.env.ref('base.group_public')
|
|
|
|
cls.admin_user = cls.env.ref('base.user_admin')
|
|
cls.internal_user = cls.env['res.users'].create({
|
|
'name': 'Internal User (Test)',
|
|
'login': 'internal',
|
|
'password': 'internal',
|
|
'groups_id': [Command.link(cls.group_user.id)]
|
|
})
|
|
cls.portal_user = cls.env['res.users'].create({
|
|
'name': 'Portal User (Test)',
|
|
'login': 'payment_portal',
|
|
'password': 'payment_portal',
|
|
'groups_id': [Command.link(cls.group_portal.id)]
|
|
})
|
|
cls.public_user = cls.env.ref('base.public_user')
|
|
|
|
cls.admin_partner = cls.admin_user.partner_id
|
|
cls.internal_partner = cls.internal_user.partner_id
|
|
cls.portal_partner = cls.portal_user.partner_id
|
|
cls.default_partner = cls.env['res.partner'].create({
|
|
'name': 'Norbert Buyer',
|
|
'lang': 'en_US',
|
|
'email': 'norbert.buyer@example.com',
|
|
'street': 'Huge Street',
|
|
'street2': '2/543',
|
|
'phone': '0032 12 34 56 78',
|
|
'city': 'Sin City',
|
|
'zip': '1000',
|
|
'country_id': cls.country_belgium.id,
|
|
})
|
|
|
|
# Create a dummy acquirer to allow basic tests without any specific acquirer implementation
|
|
arch = """
|
|
<form action="dummy" method="post">
|
|
<input type="hidden" name="view_id" t-att-value="viewid"/>
|
|
<input type="hidden" name="user_id" t-att-value="user_id.id"/>
|
|
</form>
|
|
""" # We exploit the default values `viewid` and `user_id` from QWeb's rendering context
|
|
redirect_form = cls.env['ir.ui.view'].create({
|
|
'name': "Dummy Redirect Form",
|
|
'type': 'qweb',
|
|
'arch': arch,
|
|
})
|
|
|
|
cls.dummy_acquirer = cls.env['payment.acquirer'].create({
|
|
'name': "Dummy Acquirer",
|
|
'provider': 'none',
|
|
'state': 'test',
|
|
'is_published': True,
|
|
'allow_tokenization': True,
|
|
'redirect_form_view_id': redirect_form.id,
|
|
})
|
|
|
|
cls.acquirer = cls.dummy_acquirer
|
|
cls.amount = 1111.11
|
|
cls.company = cls.env.company
|
|
cls.company_id = cls.company.id
|
|
cls.currency = cls.currency_euro
|
|
cls.partner = cls.default_partner
|
|
cls.reference = "Test Transaction"
|
|
|
|
account_payment_module = cls.env['ir.module.module']._get('account_payment')
|
|
cls.account_payment_installed = account_payment_module.state in ('installed', 'to upgrade')
|
|
|
|
def setUp(self):
|
|
def stop_patcher_without_fail():
|
|
""" Magic hack: we start the patcher even if it was started already so that we do not
|
|
call stop on a non started patcher. """
|
|
self.reconcile_after_done_patcher.start()
|
|
self.reconcile_after_done_patcher.stop()
|
|
|
|
super().setUp()
|
|
if self.account_payment_installed:
|
|
# disable account payment generation if account_payment is installed
|
|
# because the accounting setup of acquirers is not managed in this common
|
|
self.reconcile_after_done_patcher = patch(
|
|
'odoo.addons.account_payment.models.payment_transaction.PaymentTransaction._reconcile_after_done',
|
|
)
|
|
self.reconcile_after_done_patcher.start()
|
|
self.addCleanup(stop_patcher_without_fail)
|
|
|
|
#=== Utils ===#
|
|
|
|
@classmethod
|
|
def _prepare_currency(cls, currency_code):
|
|
currency = cls.env['res.currency'].with_context(active_test=False).search(
|
|
[('name', '=', currency_code.upper())]
|
|
)
|
|
currency.action_unarchive()
|
|
return currency
|
|
|
|
@classmethod
|
|
def _prepare_acquirer(cls, provider='none', company=None, update_values=None):
|
|
""" Prepare and return the first acquirer matching the given provider and company.
|
|
|
|
If no acquirer is found in the given company, we duplicate the one from the base company.
|
|
|
|
All other acquirers belonging to the same company are disabled to avoid any interferences.
|
|
|
|
:param str provider: The provider of the acquirer to prepare
|
|
:param recordset company: The company of the acquirer to prepare, as a `res.company` record
|
|
:param dict update_values: The values used to update the acquirer
|
|
:return: The acquirer to prepare, if found
|
|
:rtype: recordset of `payment.acquirer`
|
|
"""
|
|
company = company or cls.env.company
|
|
update_values = update_values or {}
|
|
|
|
acquirer = cls.env['payment.acquirer'].sudo().search(
|
|
[('provider', '=', provider), ('company_id', '=', company.id)], limit=1
|
|
)
|
|
if not acquirer:
|
|
base_acquirer = cls.env['payment.acquirer'].sudo().search(
|
|
[('provider', '=', provider)], limit=1
|
|
)
|
|
if not base_acquirer:
|
|
_logger.error("no payment.acquirer found for provider %s", provider)
|
|
return cls.env['payment.acquirer']
|
|
else:
|
|
acquirer = base_acquirer.copy({'company_id': company.id})
|
|
|
|
update_values['state'] = 'test'
|
|
acquirer.write(update_values)
|
|
return acquirer
|
|
|
|
def _create_transaction(self, flow, sudo=True, **values):
|
|
default_values = {
|
|
'amount': self.amount,
|
|
'currency_id': self.currency.id,
|
|
'acquirer_id': self.acquirer.id,
|
|
'reference': self.reference,
|
|
'operation': f'online_{flow}',
|
|
'partner_id': self.partner.id,
|
|
}
|
|
return self.env['payment.transaction'].sudo(sudo).create(dict(default_values, **values))
|
|
|
|
def _create_token(self, sudo=True, **values):
|
|
default_values = {
|
|
'payment_details': "1234",
|
|
'acquirer_id': self.acquirer.id,
|
|
'partner_id': self.partner.id,
|
|
'acquirer_ref': "Acquirer Ref (TEST)",
|
|
'active': True,
|
|
}
|
|
return self.env['payment.token'].sudo(sudo).create(dict(default_values, **values))
|
|
|
|
def _get_tx(self, reference):
|
|
return self.env['payment.transaction'].sudo().search([
|
|
('reference', '=', reference),
|
|
])
|
|
|
|
def _generate_test_access_token(self, *values):
|
|
""" Generate an access token based on the provided values for testing purposes.
|
|
|
|
This methods returns a token identical to that generated by
|
|
payment.utils.generate_access_token but uses the test class environment rather than the
|
|
environment of odoo.http.request.
|
|
|
|
See payment.utils.generate_access_token for additional details.
|
|
|
|
:param list values: The values to use for the generation of the token
|
|
:return: The generated access token
|
|
:rtype: str
|
|
"""
|
|
token_str = '|'.join(str(val) for val in values)
|
|
access_token = hmac_tool(self.env(su=True), 'generate_access_token', token_str)
|
|
return access_token
|
|
|
|
def _extract_values_from_html_form(self, html_form):
|
|
""" Extract the transaction rendering values from an HTML form.
|
|
|
|
:param str html_form: The HTML form
|
|
:return: The extracted information (action & inputs)
|
|
:rtype: dict[str:str]
|
|
"""
|
|
html_tree = objectify.fromstring(html_form)
|
|
if hasattr(html_tree, 'input'):
|
|
inputs = {input_.get('name'): input_.get('value') for input_ in html_tree.input}
|
|
else:
|
|
inputs = {}
|
|
return {
|
|
'action': html_tree.get('action'),
|
|
'method': html_tree.get('method'),
|
|
'inputs': inputs,
|
|
}
|
|
|
|
def _assert_does_not_raise(self, exception_class, func, *args, **kwargs):
|
|
""" Fail if an exception of the provided class is raised when calling the function.
|
|
|
|
If an exception of any other class is raised, it is caught and silently ignored.
|
|
|
|
This method cannot be used with functions that make requests. Any exception raised in the
|
|
scope of the new request will not be caught and will make the test fail.
|
|
|
|
:param class exception_class: The class of the exception to monitor
|
|
:param function fun: The function to call when monitoring for exceptions
|
|
:param list args: The positional arguments passed as-is to the called function
|
|
:param dict kwargs: The keyword arguments passed as-is to the called function
|
|
:return: None
|
|
"""
|
|
try:
|
|
func(*args, **kwargs)
|
|
except exception_class:
|
|
self.fail(f"{func.__name__} should not raise error of class {exception_class.__name__}")
|
|
except Exception:
|
|
pass # Any exception whose class is not monitored is caught and ignored
|