mirror of
https://github.com/bringout/oca-ocb-core.git
synced 2026-04-21 04:12:03 +02:00
433 lines
21 KiB
Python
433 lines
21 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from json.decoder import JSONDecodeError
|
|
from unittest.mock import patch
|
|
|
|
import requests
|
|
|
|
from odoo.exceptions import ValidationError
|
|
from odoo.fields import Command
|
|
from odoo.tests import tagged
|
|
from odoo.tools import mute_logger
|
|
|
|
from odoo.addons.payment.const import REPORT_REASONS_MAPPING
|
|
from odoo.addons.payment.tests.common import PaymentCommon
|
|
|
|
|
|
@tagged('-at_install', 'post_install')
|
|
class TestPaymentProvider(PaymentCommon):
|
|
|
|
def test_changing_provider_state_archives_tokens(self):
|
|
""" Test that all active tokens of a provider are archived when its state is changed. """
|
|
for old_state in ('enabled', 'test'): # No need to check when the provided was disabled.
|
|
for new_state in ('enabled', 'test', 'disabled'):
|
|
if old_state != new_state: # No need to check when the state is unchanged.
|
|
self.provider.state = old_state
|
|
token = self._create_token()
|
|
self.provider.state = new_state
|
|
self.assertFalse(token.active)
|
|
|
|
def test_enabling_provider_activates_default_payment_methods(self):
|
|
""" Test that the default payment methods of a provider are activated when it is
|
|
enabled. """
|
|
self.payment_methods.active = False
|
|
for new_state in ('enabled', 'test'):
|
|
self.provider.state = 'disabled'
|
|
with patch(
|
|
'odoo.addons.payment.models.payment_provider.PaymentProvider'
|
|
'._get_default_payment_method_codes', return_value={self.payment_method_code},
|
|
):
|
|
self.provider.state = new_state
|
|
self.assertTrue(self.payment_methods.active)
|
|
|
|
def test_enabling_manual_capture_provider_activates_compatible_default_pms(self):
|
|
"""Test that only payment methods supporting manual capture are activated when a provider
|
|
requiring manual capture is enabled."""
|
|
payment_method_with_manual_capture = self.env['payment.method'].create({
|
|
'name': 'Payment Method With Manual Capture',
|
|
'code': 'pm_with_manual_capture',
|
|
'support_manual_capture': 'full_only',
|
|
})
|
|
self.provider.state = 'disabled'
|
|
self.provider.capture_manually = True
|
|
self.provider.payment_method_ids = [Command.set([
|
|
self.payment_method.id, payment_method_with_manual_capture.id
|
|
])]
|
|
self.payment_method.support_manual_capture = 'none'
|
|
default_codes = {self.payment_method_code, payment_method_with_manual_capture.code}
|
|
with patch(
|
|
'odoo.addons.payment.models.payment_provider.PaymentProvider'
|
|
'._get_default_payment_method_codes', return_value=default_codes,
|
|
):
|
|
self.provider.state = 'test'
|
|
self.assertFalse(self.payment_methods.active)
|
|
self.assertTrue(payment_method_with_manual_capture.active)
|
|
|
|
def test_disabling_provider_deactivates_default_payment_methods(self):
|
|
""" Test that the default payment methods of a provider are deactivated when it is
|
|
disabled. """
|
|
self.payment_methods.active = True
|
|
for old_state in ('enabled', 'test'):
|
|
self.provider.state = old_state
|
|
with patch(
|
|
'odoo.addons.payment.models.payment_provider.PaymentProvider'
|
|
'._get_default_payment_method_codes', return_value=self.payment_method_code,
|
|
):
|
|
self.provider.state = 'disabled'
|
|
self.assertFalse(self.payment_methods.active)
|
|
|
|
def test_enabling_provider_activates_processing_cron(self):
|
|
""" Test that the post-processing cron is activated when a provider is enabled. """
|
|
self.env['payment.provider'].search([]).state = 'disabled' # Reset providers' state.
|
|
post_processing_cron = self.env.ref('payment.cron_post_process_payment_tx')
|
|
for enabled_state in ('enabled', 'test'):
|
|
post_processing_cron.active = False # Reset the cron's active field.
|
|
self.provider.state = 'disabled' # Prepare the dummy provider for enabling.
|
|
self.provider.state = enabled_state
|
|
self.assertTrue(post_processing_cron.active)
|
|
|
|
def test_disabling_provider_deactivates_processing_cron(self):
|
|
""" Test that the post-processing cron is deactivated when a provider is disabled. """
|
|
self.env['payment.provider'].search([]).state = 'disabled' # Reset providers' state.
|
|
post_processing_cron = self.env.ref('payment.cron_post_process_payment_tx')
|
|
for enabled_state in ('enabled', 'test'):
|
|
post_processing_cron.active = True # Reset the cron's active field.
|
|
self.provider.state = enabled_state # Prepare the dummy provider for disabling.
|
|
self.provider.state = 'disabled'
|
|
self.assertFalse(post_processing_cron.active)
|
|
|
|
def test_published_provider_compatible_with_all_users(self):
|
|
""" Test that a published provider is always available to all users. """
|
|
for user in (self.public_user, self.portal_user):
|
|
self.env = self.env(user=user)
|
|
|
|
compatible_providers = self.env['payment.provider'].sudo()._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount
|
|
)
|
|
self.assertIn(self.provider, compatible_providers)
|
|
|
|
def test_unpublished_provider_compatible_with_internal_user(self):
|
|
""" Test that an unpublished provider is still available to internal users. """
|
|
self.provider.is_published = False
|
|
|
|
compatible_providers = self.env['payment.provider']._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount
|
|
)
|
|
self.assertIn(self.provider, compatible_providers)
|
|
|
|
def test_unpublished_provider_not_compatible_with_non_internal_user(self):
|
|
""" Test that an unpublished provider is not available to non-internal users. """
|
|
self.provider.is_published = False
|
|
for user in (self.public_user, self.portal_user):
|
|
self.env = self.env(user=user)
|
|
|
|
compatible_providers = self.env['payment.provider'].sudo()._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount
|
|
)
|
|
self.assertNotIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_compatible_with_branch_companies(self):
|
|
""" Test that the provider is available to branch companies. """
|
|
branch_company = self.env['res.company'].create({
|
|
'name': "Provider Branch Company",
|
|
'parent_id': self.provider.company_id.id,
|
|
})
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
branch_company.id, self.partner.id, self.amount,
|
|
)
|
|
self.assertIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_compatible_with_available_countries(self):
|
|
""" Test that the provider is compatible with its available countries. """
|
|
belgium = self.env.ref('base.be')
|
|
self.provider.available_country_ids = [Command.set([belgium.id])]
|
|
self.partner.country_id = belgium
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount
|
|
)
|
|
self.assertIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_not_compatible_with_unavailable_countries(self):
|
|
""" Test that the provider is not compatible with a country that is not available. """
|
|
belgium = self.env.ref('base.be')
|
|
self.provider.available_country_ids = [Command.set([belgium.id])]
|
|
france = self.env.ref('base.fr')
|
|
self.partner.country_id = france
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount
|
|
)
|
|
self.assertNotIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_compatible_when_no_available_countries_set(self):
|
|
""" Test that the provider is always compatible when no available countries are set. """
|
|
self.provider.available_country_ids = [Command.clear()]
|
|
belgium = self.env.ref('base.be')
|
|
self.partner.country_id = belgium
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount
|
|
)
|
|
self.assertIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_compatible_when_maximum_amount_is_zero(self):
|
|
""" Test that the maximum amount has no effect on the provider's compatibility when it is
|
|
set to 0. """
|
|
self.provider.maximum_amount = 0.
|
|
currency = self.provider.main_currency_id.id
|
|
|
|
compatible_providers = self.env['payment.provider']._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount, currency_id=currency
|
|
)
|
|
self.assertIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_compatible_when_payment_below_maximum_amount(self):
|
|
""" Test that a provider is compatible when the payment amount is less than the maximum
|
|
amount. """
|
|
self.provider.maximum_amount = self.amount + 10.0
|
|
currency = self.provider.main_currency_id.id
|
|
|
|
compatible_providers = self.env['payment.provider']._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount, currency_id=currency
|
|
)
|
|
self.assertIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_not_compatible_when_payment_above_maximum_amount(self):
|
|
""" Test that a provider is not compatible when the payment amount is more than the maximum
|
|
amount. """
|
|
self.provider.maximum_amount = self.amount - 10.0
|
|
currency = self.provider.main_currency_id.id
|
|
|
|
compatible_providers = self.env['payment.provider']._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount, currency_id=currency
|
|
)
|
|
self.assertNotIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_compatible_with_available_currencies(self):
|
|
""" Test that the provider is compatible with its available currencies. """
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount, currency_id=self.currency_euro.id
|
|
)
|
|
self.assertIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_not_compatible_with_unavailable_currencies(self):
|
|
""" Test that the provider is not compatible with a currency that is not available. """
|
|
# Make sure the list of available currencies is not empty.
|
|
self.provider.available_currency_ids = [Command.unlink(self.currency_usd.id)]
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount, currency_id=self.currency_usd.id
|
|
)
|
|
self.assertNotIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_compatible_when_no_available_currencies_set(self):
|
|
""" Test that the provider is always compatible when no available currency is set. """
|
|
self.provider.available_currency_ids = [Command.clear()]
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount, currency_id=self.currency_euro.id
|
|
)
|
|
self.assertIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_compatible_when_tokenization_forced(self):
|
|
""" Test that the provider is compatible when it allows tokenization while it is forced by
|
|
the calling module. """
|
|
self.provider.allow_tokenization = True
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount, force_tokenization=True
|
|
)
|
|
self.assertIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_not_compatible_when_tokenization_forced(self):
|
|
""" Test that the provider is not compatible when it does not allow tokenization while it
|
|
is forced by the calling module. """
|
|
self.provider.allow_tokenization = False
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount, force_tokenization=True
|
|
)
|
|
self.assertNotIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_compatible_when_tokenization_required(self):
|
|
""" Test that the provider is compatible when it allows tokenization while it is required by
|
|
the payment context (e.g., when paying for a subscription). """
|
|
self.provider.allow_tokenization = True
|
|
with patch(
|
|
'odoo.addons.payment.models.payment_provider.PaymentProvider._is_tokenization_required',
|
|
return_value=True,
|
|
):
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount
|
|
)
|
|
self.assertIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_not_compatible_when_tokenization_required(self):
|
|
""" Test that the provider is not compatible when it does not allow tokenization while it
|
|
is required by the payment context (e.g., when paying for a subscription). """
|
|
self.provider.allow_tokenization = False
|
|
with patch(
|
|
'odoo.addons.payment.models.payment_provider.PaymentProvider._is_tokenization_required',
|
|
return_value=True,
|
|
):
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount
|
|
)
|
|
self.assertNotIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_compatible_with_express_checkout(self):
|
|
""" Test that the provider is compatible when it allows express checkout while it is an
|
|
express checkout flow. """
|
|
self.provider.allow_express_checkout = True
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount, is_express_checkout=True
|
|
)
|
|
self.assertIn(self.provider, compatible_providers)
|
|
|
|
def test_provider_not_compatible_with_express_checkout(self):
|
|
""" Test that the provider is not compatible when it does not allow express checkout while
|
|
it is an express checkout flow. """
|
|
self.provider.allow_express_checkout = False
|
|
compatible_providers = self.provider._get_compatible_providers(
|
|
self.company.id, self.partner.id, self.amount, is_express_checkout=True
|
|
)
|
|
self.assertNotIn(self.provider, compatible_providers)
|
|
|
|
def test_availability_report_covers_all_reasons(self):
|
|
""" Test that every possible unavailability reason is correctly reported. """
|
|
# Disable all providers.
|
|
providers = self.env['payment.provider'].search([])
|
|
providers.state = 'disabled'
|
|
|
|
# Prepare a base provider.
|
|
self.provider.write({
|
|
'state': 'test',
|
|
'allow_express_checkout': True,
|
|
'allow_tokenization': True,
|
|
})
|
|
|
|
# Prepare a provider with an incompatible country.
|
|
invalid_country_provider = self.provider.copy()
|
|
belgium = self.env.ref('base.be')
|
|
invalid_country_provider.write({
|
|
'state': 'test',
|
|
'available_country_ids': [Command.set([belgium.id])],
|
|
})
|
|
france = self.env.ref('base.fr')
|
|
self.partner.country_id = france
|
|
|
|
# Prepare a provider with a maximum amount lower than the payment amount.
|
|
exceeding_max_provider = self.provider.copy()
|
|
exceeding_max_provider.write({
|
|
'state': 'test',
|
|
'maximum_amount': self.amount - 10.0,
|
|
})
|
|
|
|
# Prepare a provider with an incompatible currency.
|
|
invalid_currency_provider = self.provider.copy()
|
|
invalid_currency_provider.write({
|
|
'state': 'test',
|
|
'available_currency_ids': [Command.unlink(self.currency_usd.id)],
|
|
})
|
|
|
|
# Prepare a provider without tokenization support.
|
|
no_tokenization_provider = self.provider.copy()
|
|
no_tokenization_provider.write({
|
|
'state': 'test',
|
|
'allow_tokenization': False,
|
|
})
|
|
|
|
# Prepare a provider without express checkout support.
|
|
no_express_checkout_provider = self.provider.copy()
|
|
no_express_checkout_provider.write({
|
|
'state': 'test',
|
|
'allow_express_checkout': False,
|
|
})
|
|
|
|
# Get compatible providers to generate their availability report.
|
|
report = {}
|
|
self.env['payment.provider']._get_compatible_providers(
|
|
self.company_id,
|
|
self.partner.id,
|
|
self.amount,
|
|
currency_id=self.currency_usd.id,
|
|
force_tokenization=True,
|
|
is_express_checkout=True,
|
|
report=report,
|
|
)
|
|
|
|
# Compare the generated providers report with the expected one.
|
|
expected_providers_report = {
|
|
self.provider: {
|
|
'available': True,
|
|
'reason': '',
|
|
},
|
|
invalid_country_provider: {
|
|
'available': False,
|
|
'reason': REPORT_REASONS_MAPPING['incompatible_country'],
|
|
},
|
|
exceeding_max_provider: {
|
|
'available': False,
|
|
'reason': REPORT_REASONS_MAPPING['exceed_max_amount'],
|
|
},
|
|
invalid_currency_provider: {
|
|
'available': False,
|
|
'reason': REPORT_REASONS_MAPPING['incompatible_currency'],
|
|
},
|
|
no_tokenization_provider: {
|
|
'available': False,
|
|
'reason': REPORT_REASONS_MAPPING['tokenization_not_supported'],
|
|
},
|
|
no_express_checkout_provider: {
|
|
'available': False,
|
|
'reason': REPORT_REASONS_MAPPING['express_checkout_not_supported'],
|
|
},
|
|
}
|
|
self.maxDiff = None
|
|
self.assertDictEqual(report['providers'], expected_providers_report)
|
|
|
|
def test_validation_currency_is_supported(self):
|
|
""" Test that only currencies supported by both the provider and the payment method can be
|
|
used in validation operations. """
|
|
self.provider.available_currency_ids = [Command.clear()] # Supports all currencies.
|
|
self.payment_method.supported_currency_ids = [Command.clear()] # Supports all currencies.
|
|
validation_currency = self.provider.with_context(
|
|
validation_pm=self.payment_method
|
|
)._get_validation_currency()
|
|
self.assertEqual(validation_currency, self.provider.company_id.currency_id)
|
|
|
|
self.provider.available_currency_ids = [Command.set(self.currency_usd.ids)]
|
|
self.payment_method.supported_currency_ids = [Command.clear()] # Supports all currencies.
|
|
validation_currency = self.provider.with_context(
|
|
validation_pm=self.payment_method
|
|
)._get_validation_currency()
|
|
self.assertIn(validation_currency, self.provider.available_currency_ids)
|
|
|
|
self.provider.available_currency_ids = [Command.clear()] # Supports all currencies.
|
|
self.payment_method.supported_currency_ids = [Command.set(self.currency_usd.ids)]
|
|
validation_currency = self.provider.with_context(
|
|
validation_pm=self.payment_method
|
|
)._get_validation_currency()
|
|
self.assertIn(validation_currency, self.payment_method.supported_currency_ids)
|
|
|
|
self.provider.available_currency_ids = [Command.set(self.currency_usd.ids)]
|
|
self.payment_method.supported_currency_ids = [Command.set(self.currency_usd.ids)]
|
|
validation_currency = self.provider.with_context(
|
|
validation_pm=self.payment_method
|
|
)._get_validation_currency()
|
|
self.assertIn(validation_currency, self.provider.available_currency_ids)
|
|
self.assertIn(validation_currency, self.payment_method.supported_currency_ids)
|
|
|
|
@mute_logger('odoo.addons.payment.models.payment_provider')
|
|
def test_parsing_non_json_response_falls_back_to_text_response(self):
|
|
"""Test that a non-JSON response is smoothly parsed as a text response."""
|
|
response = requests.Response()
|
|
response.status_code = 502
|
|
response._content = b"<html><body>Cloudflare Error</body></html>"
|
|
with (
|
|
patch('requests.request', return_value=response),
|
|
patch(
|
|
'odoo.addons.payment.models.payment_provider.PaymentProvider._parse_response_error',
|
|
new=lambda _self, _response: _response.json(),
|
|
),
|
|
):
|
|
try:
|
|
self.provider._send_api_request('GET', '/dummy')
|
|
except Exception as e: # noqa: BLE001
|
|
self.assertNotIsInstance(e, JSONDecodeError)
|
|
self.assertIsInstance(e, ValidationError)
|
|
self.assertIn("Cloudflare Error", e.args[0])
|