1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
from unittest.mock import patch
from odoo import Command
from odoo.tests import tagged
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_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_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_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)
|
