class TestRecurring(unittest.TestCase):
ady = Adyen.Adyen()
client = ady.client
test = BaseTest(ady)
client.username = "******"
client.password = "******"
client.platform = "test"
client.app_name = "appname"
def test_list_recurring_details(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request["shopperEmail"] = "*****@*****.**"
request["shopperReference"] = "ref"
request['recurring'] = {}
request["recurring"]['contract'] = "RECURRING"
self.ady.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'recurring/'
'listRecurring'
'Details-'
'success.json')
result = self.ady.recurring.list_recurring_details(request)
self.assertEqual(1, len(result.message['details']))
self.assertEqual(1, len(result.message['details'][0]))
recurringDetail = result.message['details'][0]['RecurringDetail']
self.assertEqual("recurringReference",
recurringDetail['recurringDetailReference'])
self.assertEqual("cardAlias", recurringDetail['alias'])
self.assertEqual("1111", recurringDetail['card']['number'])
def test_disable(self):
request = {}
request["shopperEmail"] = "*****@*****.**"
request["shopperReference"] = "ref"
request["recurringDetailReference"] = "12345678889"
self.ady.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'recurring/'
'disable-success'
'.json')
result = self.ady.recurring.disable(request)
self.assertEqual(1, len(result.message['details']))
self.assertEqual("[detail-successfully-disabled]",
result.message['response'])
def test_disable_803(self):
request = {}
request["shopperEmail"] = "*****@*****.**"
request["shopperReference"] = "ref"
request["recurringDetailReference"] = "12345678889"
self.ady.client = self.test.create_client_from_file(
422, request, 'test/mocks/'
'recurring/'
'disable-error-803'
'.json')
self.assertRaisesRegexp(Adyen.AdyenAPICommunicationError,
"Unexpected error", self.ady.recurring.disable,
request)
def handle(self, *args, **options):
ady = Adyen.Adyen()
# Setting global values
ady.payment.client.platform = settings.DJADYEN_ENVIRONMENT
ady.payment.client.xapikey = settings.DJADYEN_SERVER_KEY
ady.payment.client.app_name = settings.DJADYEN_APPNAME
# Setting request data.
request = {
"merchantAccount": settings.DJADYEN_MERCHANT_ACCOUNT,
}
# Starting the checkout.
result = ady.checkout.payment_methods(request)
payment_methods = result.message.get("paymentMethods")
for payment_method in payment_methods:
name = payment_method.get("name")
type = payment_method.get("type")
brands = payment_method.get("brands")
issuers = payment_method.get("issuers", [])
if brands:
for brand in brands:
create_payment_method(brand, name, issuers)
else:
create_payment_method(type, name, issuers)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
configuration = {
item["name"]: item["value"]
for item in self.configuration
}
self.config = GatewayConfig(
gateway_name=GATEWAY_NAME,
auto_capture=configuration["auto-capture"],
supported_currencies=configuration["supported-currencies"],
connection_params={
"api_key": configuration["api-key"],
"merchant_account": configuration["merchant-account"],
"client_key": configuration["client-key"],
"origin_url": configuration["origin-url"],
"live": configuration["live"],
"webhook_hmac": configuration["hmac-secret-key"],
"webhook_user": configuration["notification-user"],
"webhook_user_password":
configuration["notification-password"],
"adyen_auto_capture": configuration["adyen-auto-capture"],
},
)
api_key = self.config.connection_params["api_key"]
live_endpoint = self.config.connection_params["live"] or None
platform = "live" if live_endpoint else "test"
self.adyen = Adyen.Adyen(xapikey=api_key,
live_endpoint_prefix=live_endpoint,
platform=platform)
class UtilTest(unittest.TestCase):
ady = Adyen.Adyen()
client = ady.client
def test_notification_request_item_hmac(self):
request = {
"pspReference": "pspReference",
"originalReference": "originalReference",
"merchantAccount": "merchantAccount",
"amount": {
"currency": "EUR",
"value": 100000
},
"eventCode": "EVENT",
"Success": "true"
}
key = "DFB1EB5485895CFA84146406857104AB" \
"B4CBCABDC8AAF103A624C8F6A3EAAB00"
hmac_calculation = generate_hpp_sig(request, key)
hmac_calculation_str = hmac_calculation.decode("utf-8")
expected_hmac = "+xK25vgc9XcZFwu7WNLIwqVewyumVsgp+X+C0a2e+DE="
self.assertTrue(hmac_calculation_str != "")
self.assertEqual(hmac_calculation_str, expected_hmac)
request['additionalData'] = {'hmacSignature': hmac_calculation_str}
hmac_validate = is_valid_hmac(request, key)
self.assertTrue(hmac_validate)
def test_adyen_check_payment_balance_adyen_raises_error(
api_call_mock, adyen_plugin, adyen_check_balance_response
):
api_call_mock.return_value = Adyen.AdyenError("Error")
plugin = adyen_plugin()
data = {
"gatewayId": "mirumee.payments.gateway",
"method": "givex",
"card": {
"cvc": "9891",
"code": "1234567910",
"money": {"currency": "GBP", "amount": Decimal(100.0)},
},
}
result = plugin.check_payment_balance(data)
assert result == "Error"
api_call_mock.assert_called_once_with(
{
"merchantAccount": "SaleorECOM",
"paymentMethod": {
"type": "givex",
"number": "1234567910",
"securityCode": "9891",
},
"amount": {"currency": "GBP", "value": "10000"},
},
plugin.adyen.checkout.client.call_checkout_api,
action="paymentMethods/balance",
)
def __init__(self, *args, **kwargs):
channel = kwargs["channel"]
raw_configuration = kwargs["configuration"].copy()
self._insert_webhook_endpoint_to_configuration(raw_configuration, channel)
kwargs["configuration"] = raw_configuration
super().__init__(*args, **kwargs)
configuration = {item["name"]: item["value"] for item in self.configuration}
self.config = GatewayConfig(
gateway_name=GATEWAY_NAME,
auto_capture=configuration["auto-capture"],
supported_currencies=configuration["supported-currencies"],
connection_params={
"api_key": configuration["api-key"],
"merchant_account": configuration["merchant-account"],
"client_key": configuration["client-key"],
"live": configuration["live"],
"webhook_hmac": configuration["hmac-secret-key"],
"webhook_user": configuration["notification-user"],
"webhook_user_password": configuration["notification-password"],
"adyen_auto_capture": configuration["adyen-auto-capture"],
"enable_native_3d_secure": configuration["enable-native-3d-secure"],
"apple_pay_cert": configuration["apple-pay-cert"],
},
)
api_key = self.config.connection_params["api_key"]
live_endpoint = self.config.connection_params["live"] or None
platform = "live" if live_endpoint else "test"
self.adyen = Adyen.Adyen(
xapikey=api_key, live_endpoint_prefix=live_endpoint, platform=platform
)
def _init_api(self, env=None):
self.adyen = Adyen.Adyen(
app_name='pretix',
xapikey=self.settings.test_api_key
if self.event.testmode else self.settings.prod_api_key,
# API-calls go only to -live in prod - not to -live-au or -live-us like in the frontend.
platform=env if env else 'test' if self.event.testmode else 'live',
live_endpoint_prefix=self.settings.prod_prefix)
def get_adyen_instance(get_method=False):
adyen = Adyen.Adyen()
client = adyen.client
client.hmac = os.environ.get('ADYEN_HMAC')
client.platform = os.environ.get('ADYEN_PLATFORM')
client.app_name = os.environ.get('ADYEN_APP_NAME')
if not get_method:
client.username = os.environ.get('ADYEN_USERNAME')
client.password = os.environ.get('ADYEN_PASSWORD')
return adyen
def initialize_adyen_client(config: GatewayConfig) -> Adyen.Adyen:
api_key = config.connection_params["api_key"]
live_endpoint = config.connection_params.get("live")
platform = "live" if live_endpoint else "test"
adyen = Adyen.Adyen(xapikey=api_key,
live_endpoint_prefix=live_endpoint,
platform=platform)
init_http_client(adyen)
return adyen
def _get_adyen_client(self):
account = self._get_account()
data = account.get_data()
ady = Adyen.Adyen()
ady.payment.client.username = data['username']
ady.payment.client.platform = str(data['platform'])
ady.payment.client.merchant_account = data['merchant_account']
ady.payment.client.password = account._get_password()
ady.payment.client.app_name = data['app_name']
return ady.payment
class TestDirectoryLookup(unittest.TestCase):
ady = Adyen.Adyen()
client = ady.client
test = BaseTest(ady)
client.username = "******"
client.password = "******"
client.platform = "test"
client.hmac = "DFB1EB5485895CFA84146406857104A" \
"BB4CBCABDC8AAF103A624C8F6A3EAAB00"
def test_get_post_parameters(self):
request = {
'merchantAccount': "testmerchantaccount",
'paymentAmount': "1000",
'currencyCode': "EUR",
'merchantReference': "Get Payment methods",
'skinCode': "testskincode",
'countryCode': "NL",
'shopperLocale': "nl_NL",
'sessionValidity': time.strftime('%Y-%m-%dT%H:%M:%SZ')
}
self.test.create_client_from_file(200, request, None)
result = self.ady.hpp.hpp_payment(request)
self.assertEqual("EUR", result["message"]["currencyCode"])
self.assertEqual(44, len(result["message"]["merchantSig"]))
def test_get_payment_methods(self):
request = {
'merchantAccount': "testmerchantaccount",
'paymentAmount': "1000",
'currencyCode': "EUR",
'merchantReference': "Get Payment methods",
'skinCode': "testskincode",
'countryCode': "NL",
'shopperLocale': "nl_NL",
'sessionValidity': time.strftime('%Y-%m-%dT%H:%M:%SZ')
}
self.test.create_client_from_file(200, request,
'test/mocks/hpp/'
'directoryLookup-success.json')
result = self.ady.hpp.directory_lookup(request)
self.assertEqual(8, len(result.message['paymentMethods']))
ideal = result.message['paymentMethods'][0]
self.assertEqual("ideal", ideal['brandCode'])
self.assertEqual("iDEAL", ideal['name'])
self.assertEqual(3, len(ideal['issuers']))
issuer1 = ideal['issuers'][0]
self.assertEqual("1121", issuer1['issuerId'])
self.assertEqual("Test Issuer", issuer1['name'])
visa = result.message['paymentMethods'][1]
self.assertEqual("visa", visa['brandCode'])
class UtilTest(unittest.TestCase):
ady = Adyen.Adyen()
client = ady.client
def test_hpp_request_item_hmac(self):
request = {
"pspReference": "pspReference",
"originalReference": "originalReference",
"merchantAccount": "merchantAccount",
"amount": {
"currency": "EUR",
"value": 100000
},
"eventCode": "EVENT",
"Success": "true"
}
key = "DFB1EB5485895CFA84146406857104AB" \
"B4CBCABDC8AAF103A624C8F6A3EAAB00"
hmac_calculation = generate_hpp_sig(request, key)
hmac_calculation_str = hmac_calculation.decode("utf-8")
expected_hmac = "+xK25vgc9XcZFwu7WNLIwqVewyumVsgp+X+C0a2e+DE="
self.assertTrue(hmac_calculation_str != "")
self.assertEqual(hmac_calculation_str, expected_hmac)
request['additionalData'] = {'hmacSignature': hmac_calculation_str}
hmac_validate = is_valid_hmac(request, key)
self.assertTrue(hmac_validate)
def test_notification_request_item_hmac(self):
request = {
"pspReference": "7914073381342284",
"merchantReference": "TestPayment-1407325143704",
"merchantAccountCode": "TestMerchant",
"amount": {
"currency": "EUR",
"value": 1130
},
"eventCode": "AUTHORISATION",
"success": "true",
"eventDate": "2019-05-06T17:15:34.121+02:00",
"operations": ["CANCEL", "CAPTURE", "REFUND"],
"paymentMethod": "visa",
}
key = "44782DEF547AAA06C910C43932B1EB0C" \
"71FC68D9D0C057550C48EC2ACF6BA056"
hmac_calculation = generate_notification_sig(request, key)
hmac_calculation_str = hmac_calculation.decode("utf-8")
expected_hmac = "coqCmt/IZ4E3CzPvMY8zTjQVL5hYJUiBRg8UU+iCWo0="
self.assertTrue(hmac_calculation_str != "")
self.assertEqual(hmac_calculation_str, expected_hmac)
request['additionalData'] = {'hmacSignature': hmac_calculation_str}
hmac_validate = is_valid_hmac_notification(request, key)
self.assertTrue(hmac_validate)
def handle_shopper_redirect(values):
adyen = Adyen.Adyen()
adyen.payment.client.platform = "test"
adyen.client.xapikey = config.checkout_apikey
details_request = values
print("/payments/details request:\n" + str(details_request))
details_response = adyen.checkout.payments_details(details_request)
print("payments/details response:\n" + details_response.raw_response)
return json.loads(details_response.raw_response)
def ady_clientInit():
print("Adyen API is about to be initialized.")
ady = Adyen.Adyen()
ady.client.xapikey = secrets()['xapikey']
ady.client.platform = secrets()['platform']
# TODO Not in documentation, needed otherwise following error
# requests.exceptions.InvalidHeader: Invalid return character or leading space in header: User-Agent
ady.client.app_name = secrets()['app_name']
print("Adyen API is initialized.")
return ady
class TestDetermineUrl(unittest.TestCase):
adyen = Adyen.Adyen()
client = adyen.client
test = BaseTest(adyen)
client.xapikey = "YourXapikey"
client.app_name = "appname"
def test_checkout_api_url_custom(self):
self.client.live_endpoint_prefix = "1797a841fbb37ca7-AdyenDemo"
url = self.adyen.client._determine_checkout_url("live", "payments")
self.client.live_endpoint_prefix = "1797a841fbb37ca7-AdyenDemo"
self.assertEqual(
url, "https://1797a841fbb37ca7-AdyenDemo-checkout-"
"live.adyenpayments.com/checkout/v41/payments")
def test_checkout_api_url(self):
self.client.live_endpoint_prefix = None
url = self.adyen.client._determine_checkout_url(
"test", "paymentsDetails")
self.assertEqual(
url, "https://checkout-test.adyen.com"
"/v41/payments/details")
def test_payments_invalid_platform(self):
request = {
'amount': {
"value": "100000",
"currency": "EUR"
},
"reference": "Your order number",
'paymentMethod': {
"type": "scheme",
"number": "4111111111111111",
"expiryMonth": "08",
"expiryYear": "2018",
"holderName": "John Smith",
"cvc": "737"
},
'merchantAccount': "YourMerchantAccount",
'returnUrl': "https://your-company.com/..."
}
self.client.platform = "live"
self.client.live_endpoint_prefix = None
try:
result = self.adyen.checkout.payments(request)
except AdyenEndpointInvalidFormat as error:
self.assertIsNotNone(error)
def __init__(self):
# Initialize the adyen client
kwargs = {
'xapikey':
os.environ.get('AO_ADYEN_API_KEY', ''),
'platform':
os.environ.get('AO_ADYEN_PLATFORM', 'test'),
'merchant_account':
os.environ.get('AO_ADYEN_MERCHANT_ACCOUNT', ''),
'live_endpoint_prefix':
os.environ.get('AO_ADYEN_LIVE_ENDPOINT_PREFIX', ''),
}
self._ayden_instance = Adyen.Adyen(**kwargs)
self._ayden_instance.client = CustomAdyenClient(**kwargs)
class TestCheckoutUtility(unittest.TestCase):
ady = Adyen.Adyen()
client = ady.client
test = BaseTest(ady)
client.xapikey = "YourXapikey"
client.platform = "test"
client.app_name = "appname"
def test_origin_keys_success_mocked(self):
request = {
"originDomains": {
"https://www.your-domain1.com", "https://www.your-domain2.com",
"https://www.your-domain3.com"
}
}
self.ady.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkoututility/"
"originkeys"
"-success.json")
result = self.ady.checkout.origin_keys(request)
self.assertEqual(
"pub.v2.7814286629520534.aHR0cHM6Ly93d3cu"
"eW91ci1kb21haW4xLmNvbQ.UEwIBmW9-c_uXo5wS"
"Er2w8Hz8hVIpujXPHjpcEse3xI",
result.message['originKeys']['https://www.your-domain1.com'])
self.assertEqual(
"pub.v2.7814286629520534.aHR0cHM6Ly93d3cu"
"eW91ci1kb21haW4zLmNvbQ.fUvflu-YIdZSsLEH8"
"Qqmr7ksE4ag_NYiiMXK0s6aq_4",
result.message['originKeys']['https://www.your-domain3.com'])
self.assertEqual(
"pub.v2.7814286629520534.aHR0cHM6Ly93d3cue"
"W91ci1kb21haW4yLmNvbQ.EP6eXBJKk0t7-QIUl6e_"
"b1qMuMHGepxG_SlUqxAYrfY",
result.message['originKeys']['https://www.your-domain2.com'])
def test_checkout_utility_api_url_custom(self):
url = self.ady.client._determine_checkout_url("test", "originKeys")
self.assertEqual(url, "https://checkout-test.adyen.com/v1/originKeys")
def adyen_payment_component(order):
"""
Will display a singular payment method.
"""
ady = Adyen.Adyen()
# Setting global values
ady.payment.client.platform = settings.DJADYEN_ENVIRONMENT
ady.payment.client.xapikey = settings.DJADYEN_SERVER_KEY
ady.payment.client.app_name = settings.DJADYEN_APPNAME
# Setting request data.
request = {
"amount": {
"value": order.get_price_in_cents(),
"currency": settings.DJADYEN_CURRENCYCODE,
},
"reference": str(order.reference),
"merchantAccount": settings.DJADYEN_MERCHANT_ACCOUNT,
"returnUrl": order.get_return_url(),
}
# Starting the checkout.
result = ady.checkout.sessions(request)
if result.status_code == 201:
return {
"client_key":
settings.DJADYEN_CLIENT_KEY,
"session_id":
result.message.get("id"),
"session_data":
result.message.get("sessionData"),
"environment":
settings.DJADYEN_ENVIRONMENT,
"redirect_url":
order.get_return_url,
"language":
get_language(),
"payment_type":
order.payment_option.adyen_name if order.payment_option else "",
"issuer":
order.issuer.adyen_id if order.issuer else "",
}
return {}
def get_payment_methods():
adyen = Adyen.Adyen()
adyen.client.xapikey = 'AQEyhmfxLI/IbBZKw0m/n3Q5qf3VaY9UCJ14XWZE03G/k2NFihja6KR9b5EFAR0H0jGxRuEQwV1bDb7kfNy1WIxIIkxgBw==-TaV30ekCd9bVxvqjn/Enaf7Udh5r1ZG77dvt13opS+Q=-J;Q5y(=k8*Eb6Zt2'
request = {
"merchantAccount": "AdyenRecruitmentCOM",
"countryCode": "NL",
"amount": {
"currency": "EUR",
"value": 1000
},
"channel": "Web",
"shopperLocale": "nl-NL"
}
response = adyen.checkout.payment_methods(request)
response = response.message
for paymentmtd in response['groups']:
print(paymentmtd)
return response
def adyen_payment_methods():
adyen = Adyen.Adyen()
adyen.client.platform = 'test'
adyen.client.xapikey = config.checkout_apikey
payment_methods_request = {
'merchantAccount': config.merchant_account,
'reference': 'Fusion paymentMethods call',
'shopperReference': 'Python Checkout Shopper',
'channel': 'Web',
}
print("/paymentMethods request:\n" + str(payment_methods_request))
payment_methods_response = adyen.checkout.payment_methods(
payment_methods_request)
formatted_response = json.dumps(
(json.loads(payment_methods_response.raw_response)))
print("/paymentMethods response:\n" + formatted_response)
return formatted_response
def ady_paymentMethods(country, currency):
# Import all secrets
secret = secrets()
ady = Adyen.Adyen()
client = ady.client
client.xapikey = secret['xapikey']
client.platform = secret['platform']
client.app_name = secret['app_name']
request = {
'merchantAccount': secret['merchantAccount'],
'countryCode': country,
'amount': {
'value': 100,
'currency': currency,
},
'channel': 'Web'
}
response = ady.checkout.payment_methods(request)
return response
class TestPayments(unittest.TestCase):
adyen = Adyen.Adyen()
client = adyen.client
test = BaseTest(adyen)
client.username = "******"
client.password = "******"
client.platform = "test"
client.app_name = "appname"
def test_authorise_success_mocked(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['amount'] = {"value": "100000", "currency": "EUR"}
request['reference'] = "123456"
request['card'] = {
"number": "5136333333333335",
"expiryMonth": "08",
"expiryYear": "2018",
"cvc": "737",
"holderName": "John Doe"
}
self.adyen.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'authorise'
'-success'
'.json')
result = self.adyen.payment.authorise(request)
self.assertEqual("Authorised", result.message['resultCode'])
self.assertEqual("8/2018",
result.message['additionalData']['expiryDate'])
self.assertEqual("411111", result.message['additionalData']['cardBin'])
self.assertEqual("1111",
result.message['additionalData']['cardSummary'])
self.assertEqual("Holder",
result.message['additionalData']['cardHolderName'])
self.assertEqual("true",
result.message['additionalData']['threeDOffered'])
self.assertEqual(
"false", result.message['additionalData']['threeDAuthenticated'])
self.assertEqual("69746", result.message['authCode'])
self.assertEqual(11, len(result.message['fraudResult']['results']))
fraud_checks = result.message['fraudResult']['results']
fraud_check_result = fraud_checks[0]['FraudCheckResult']
self.assertEqual("CardChunkUsage", fraud_check_result['name'])
self.assertEqual(8, fraud_check_result['accountScore'])
self.assertEqual(2, fraud_check_result['checkId'])
def test_authorise_error010_mocked(self):
request = {}
request['merchantAccount'] = "testaccount"
request['amount'] = {"value": "100000", "currency": "EUR"}
request['reference'] = "123456"
request['card'] = {
"number": "5136333333333335",
"expiryMonth": "08",
"expiryYear": "2018",
"cvc": "737",
"holderName": "John Doe"
}
self.adyen.client = self.test.create_client_from_file(
403, request, 'test/mocks/'
'authorise-error'
'-010'
'.json')
self.assertRaises(Adyen.AdyenAPIInvalidPermission,
self.adyen.payment.authorise, request)
def test_authorise_error_cvc_declined_mocked(self):
request = {}
request['amount'] = {"value": "100000", "currency": "EUR"}
request['reference'] = "123456"
request['card'] = {
"number": "5136333333333335",
"expiryMonth": "08",
"expiryYear": "2018",
"cvc": "787",
"holderName": "John Doe"
}
self.adyen.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'authorise'
'-error-'
'cvc-declined'
'.json')
result = self.adyen.payment.authorise(request)
self.assertEqual("Refused", result.message['resultCode'])
def test_authorise_success_3d_mocked(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['amount'] = {"value": "100000", "currency": "EUR"}
request['reference'] = "123456"
request['card'] = {
"number": "5136333333333335",
"expiryMonth": "08",
"expiryYear": "2018",
"cvc": "787",
"holderName": "John Doe"
}
request['browserInfo'] = {
"userAgent": "YourUserAgent",
"acceptHeader": "YourAcceptHeader"
}
self.adyen.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'authorise'
'-success'
'-3d.json')
result = self.adyen.payment.authorise(request)
self.assertEqual("RedirectShopper", result.message['resultCode'])
self.assertIsNotNone(result.message['md'])
self.assertIsNotNone(result.message['issuerUrl'])
self.assertIsNotNone(result.message['paRequest'])
def test_authorise_3d_success_mocked(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['md'] = "testMD"
request['paResponse'] = "paresponsetest"
request['browserInfo'] = {
"userAgent": "YourUserAgent",
"acceptHeader": "YourAcceptHeader"
}
self.adyen.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'authorise3d-'
'success.json')
result = self.adyen.payment.authorise3d(request)
self.assertEqual("Authorised", result.message['resultCode'])
self.assertIsNotNone(result.message['pspReference'])
def test_authorise_cse_success_mocked(self):
request = {}
request['amount'] = {"value": "1234", "currency": "EUR"}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['additionalData'] = {"card.encrypted.json": "YourCSEToken"}
self.adyen.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'authorise'
'-success'
'-cse.json')
result = self.adyen.payment.authorise(request)
self.assertEqual("Authorised", result.message['resultCode'])
def test_authorise_cse_error_expired_mocked(self):
request = {}
request['amount'] = {"value": "1234", "currency": "EUR"}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['additionalData'] = {"card.encrypted.json": "YourCSEToken"}
self.adyen.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'authorise'
'-error-'
'expired.json')
result = self.adyen.payment.authorise(request)
self.assertEqual("Refused", result.message['resultCode'])
self.assertEqual("DECLINED Expiry Incorrect",
result.message['additionalData']['refusalReasonRaw'])
def test_error_401_mocked(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['amount'] = {"value": "100000", "currency": "EUR"}
request['reference'] = "123456"
request['card'] = {
"number": "5136333333333335",
"expiryMonth": "08",
"expiryYear": "2018",
"cvc": "787",
"holderName": "John Doe"
}
self.adyen.client = self.test.create_client_from_file(
401, request, 'test/mocks/'
'authorise'
'-error-'
'010.json')
self.assertRaisesRegexp(
Adyen.AdyenAPIAuthenticationError,
"Unable to authenticate with Adyen's Servers."
" Please verify the credentials set with the"
" Adyen base class. Please reach out to your"
" Adyen Admin if the problem persists",
self.adyen.payment.authorise, request)
class TestThirdPartyPayout(unittest.TestCase):
ady = Adyen.Adyen()
client = ady.client
test = BaseTest(ady)
client.username = "******"
client.password = "******"
client.platform = "test"
client.app_name = "appname"
client.review_payout_username = "******"
client.review_payout_password = "******"
client.store_payout_username = "******"
client.store_payout_password = "******"
def test_confirm_success(self):
request = {}
request["merchantAccount"] = "YourMerchantAccount"
request["originalReference"] = "YourReference"
resp = 'test/mocks/payout/confirm-success.json'
self.ady.client = self.test.create_client_from_file(200, request, resp)
result = self.ady.payout.confirm(request)
self.assertIsNotNone(result.message['pspReference'])
expected = "[payout-confirm-received]"
self.assertEqual(expected, result.message['resultCode'])
def test_confirm_missing_reference(self):
request = {}
request["merchantAccount"] = "YourMerchantAccount"
request["originalReference"] = ""
resp = 'test/mocks/payout/confirm-missing-reference.json'
self.ady.client = self.test.create_client_from_file(500, request, resp)
self.assertRaisesRegexp(
Adyen.AdyenAPIValidationError,
"Received validation error with errorCode: 702,"
" message: Required field 'merchantAccount' is null,"
" HTTP Code: 500. Please verify the values provided.",
self.ady.payout.confirm, request)
def test_decline_success(self):
request = {}
request["merchantAccount"] = "YourMerchantAccount"
request["originalReference"] = "YourReference"
resp = 'test/mocks/payout/decline-success.json'
self.ady.client = self.test.create_client_from_file(200, request, resp)
result = self.ady.payout.confirm(request)
self.assertIsNotNone(result.message['pspReference'])
expected = "[payout-decline-received]"
self.assertEqual(expected, result.message['resultCode'])
def test_decline_missing_reference(self):
request = {}
request["merchantAccount"] = "YourMerchantAccount"
request["originalReference"] = ""
resp = 'test/mocks/payout/decline-missing-reference.json'
self.ady.client = self.test.create_client_from_file(500, request, resp)
self.assertRaisesRegexp(
Adyen.AdyenAPIValidationError,
"Received validation error with errorCode: 702,"
" message: Required field 'merchantAccount' is null,"
" HTTP Code: 500. Please verify the values provided.",
self.ady.payout.confirm, request)
def test_store_detail_bank_success(self):
request = {}
request["bank"] = {
"bankName": "AbnAmro",
"bic": "ABNANL2A",
"countryCode": "NL",
"iban": "NL32ABNA0515071439",
"ownerName": "Adyen",
"bankCity": "Amsterdam",
"taxId": "bankTaxId"
}
request["merchantAccount"] = "YourMerchantAccount"
request["recurring"] = {"contract": "PAYOUT"}
request["shopperEmail"] = "*****@*****.**"
request["shopperReference"] = "ref"
resp = 'test/mocks/payout/storeDetail-success.json'
self.ady.client = self.test.create_client_from_file(200, request, resp)
result = self.ady.payout.store_detail(request)
self.assertIsNotNone(result.message['pspReference'])
self.assertIsNotNone(result.message['recurringDetailReference'])
expected = "Success"
self.assertEqual(expected, result.message['resultCode'])
def test_submit_success(self):
request = {}
request["amount"] = {"value": "100000", "currency": "EUR"}
request["reference"] = "payout-test"
request["recurring"] = {"contract": "PAYOUT"}
request["merchantAccount"] = "YourMerchantAccount"
request["shopperEmail"] = "*****@*****.**"
request["shopperReference"] = "ref"
request["selectedRecurringDetailReference"] = "LATEST"
resp = 'test/mocks/payout/submit-success.json'
self.ady.client = self.test.create_client_from_file(200, request, resp)
result = self.ady.payout.submit(request)
self.assertIsNotNone(result.message['pspReference'])
expected = "[payout-submit-received]"
self.assertEqual(expected, result.message['resultCode'])
def test_submit_invalid_recurring_reference(self):
request = {}
request["amount"] = {"value": "100000", "currency": "EUR"}
request["reference"] = "payout-test"
request["recurring"] = {"contract": "PAYOUT"}
request["merchantAccount"] = "YourMerchantAccount"
request["shopperEmail"] = "*****@*****.**"
request["shopperReference"] = "ref"
request["selectedRecurringDetailReference"] = "1234"
resp = 'test/mocks/payout/submit-invalid-reference.json'
self.ady.client = self.test.create_client_from_file(422, request, resp)
self.assertRaisesRegexp(
Adyen.AdyenAPIValidationError,
"Received validation error with errorCode: 800,"
" message: Contract not found, HTTP Code: 422."
" Please verify the values provided."
" Please reach out to [email protected]"
" if the problem persists, providing the PSP reference.*",
self.ady.payout.submit, request)
def test_store_detail_and_submit_missing_reference(self):
request = {}
request["amount"] = {"value": "100000", "currency": "EUR"}
request["merchantAccount"] = "YourMerchantAccount"
request["recurring"] = {"contract": "PAYOUT"}
request["shopperEmail"] = "*****@*****.**"
request["shopperReference"] = "ref"
request["bank"] = {
"iban": "NL32ABNA0515071439",
"ownerName": "Adyen",
"countryCode": "NL",
}
self.assertRaisesRegexp(
ValueError, "Provide the required request parameters"
" to complete this request: \nreference",
self.ady.payout.store_detail_and_submit, request)
def test_store_detail_and_submit_missing_payment(self):
request = {}
request["amount"] = {"value": "100000", "currency": "EUR"}
request["merchantAccount"] = "YourMerchantAccount"
request["reference"] = "payout-test"
request["recurring"] = {"contract": "PAYOUT"}
request["shopperEmail"] = "*****@*****.**"
request["shopperReference"] = "ref"
resp = 'test/mocks/payout/storeDetailAndSubmit-missing-payment.json'
self.ady.client = self.test.create_client_from_file(422, request, resp)
self.assertRaisesRegexp(
Adyen.AdyenAPIValidationError,
"Received validation error with errorCode: 000,"
" message: Please supply paymentDetails, HTTP Code: 422."
" Please verify the values provided."
" Please reach out to [email protected]"
" if the problem persists, providing the PSP reference:.*",
self.ady.payout.store_detail_and_submit, request)
def test_store_detail_and_submit_invalid_iban(self):
request = {}
request["amount"] = {"value": "100000", "currency": "EUR"}
request["merchantAccount"] = "YourMerchantAccount"
request["reference"] = "payout-test"
request["recurring"] = {"contract": "PAYOUT"}
request["shopperEmail"] = "*****@*****.**"
request["shopperReference"] = "ref"
request["bank"] = {
"countryCode": "NL",
"iban": "4111111111111111",
"ownerName": "Adyen",
}
request["merchantAccount"] = "YourMerchantAccount"
resp = 'test/mocks/payout/storeDetailAndSubmit-invalid-iban.json'
self.ady.client = self.test.create_client_from_file(422, request, resp)
self.assertRaisesRegexp(
Adyen.AdyenAPIValidationError,
"Received validation error with errorCode: 161,"
" message: Invalid iban, HTTP Code: 422."
" Please verify the values provided."
" Please reach out to [email protected]"
" if the problem persists, providing the PSP reference:.*",
self.ady.payout.store_detail_and_submit, request)
def test_store_detail_and_submit_card_success(self):
request = {}
request["amount"] = {"value": "100000", "currency": "EUR"}
request["merchantAccount"] = "YourMerchantAccount"
request["reference"] = "payout-test"
request["recurring"] = {"contract": "PAYOUT"}
request["shopperEmail"] = "*****@*****.**"
request["shopperReference"] = "ref"
request["card"] = {
"number": "4111111111111111",
"expiryMonth": "08",
"expiryYear": "2018",
"cvc": "737",
"holderName": "John Smith"
}
resp = 'test/mocks/payout/storeDetailAndSubmit-card-success.json'
self.ady.client = self.test.create_client_from_file(200, request, resp)
result = self.ady.payout.store_detail_and_submit(request)
self.assertIsNotNone(result.message['pspReference'])
expected = "[payout-submit-received]"
self.assertEqual(expected, result.message['resultCode'])
def test_store_detail_and_submit_bank_success(self):
request = {}
request["amount"] = {"value": "100000", "currency": "EUR"}
request["bank"] = {
"countryCode": "NL",
"iban": "NL32ABNA0515071439",
"ownerName": "Adyen",
}
request["merchantAccount"] = "YourMerchantAccount"
request["recurring"] = {"contract": "PAYOUT"}
request["reference"] = "YourReference"
request["shopperEmail"] = "*****@*****.**"
request["shopperReference"] = "ref"
resp = 'test/mocks/payout/storeDetailAndSubmit-bank-success.json'
self.ady.client = self.test.create_client_from_file(200, request, resp)
result = self.ady.payout.store_detail_and_submit(request)
self.assertIsNotNone(result.message['pspReference'])
expected = "[payout-submit-received]"
self.assertEqual(expected, result.message['resultCode'])
class TestCheckout(unittest.TestCase):
adyen = Adyen.Adyen()
client = adyen.client
test = BaseTest(adyen)
client.xapikey = "YourXapikey"
client.platform = "test"
def test_payment_methods_success_mocked(self):
request = {'merchantAccount': "YourMerchantAccount"}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"paymentmethods"
"-success.json")
result = self.adyen.checkout.payment_methods(request)
self.assertEqual("AliPay", result.message['paymentMethods'][0]['name'])
self.assertEqual("Credit Card",
result.message['paymentMethods'][2]['name'])
self.assertEqual("Credit Card via AsiaPay",
result.message['paymentMethods'][3]['name'])
def test_payment_methods_error_mocked(self):
request = {'merchantAccount': "YourMerchantAccount"}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"paymentmethods-"
"error-forbidden"
"-403.json")
result = self.adyen.checkout.payment_methods(request)
self.assertEqual(403, result.message['status'])
self.assertEqual("901", result.message['errorCode'])
self.assertEqual("Invalid Merchant Account", result.message['message'])
self.assertEqual("security", result.message['errorType'])
def test_payments_success_mocked(self):
request = {
'amount': {
"value": "100000",
"currency": "EUR"
},
'reference': "123456",
'paymentMethod': {
"type": "scheme",
"number": "4111111111111111",
"expiryMonth": "08",
"expiryYear": "2018",
"holderName": "John Smith",
"cvc": "737"
},
'merchantAccount': "YourMerchantAccount",
'returnUrl': "https://your-company.com/..."
}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"payments"
"-success"
".json")
result = self.adyen.checkout.payments(request)
self.assertEqual("8535296650153317", result.message['pspReference'])
self.assertEqual("Authorised", result.message['resultCode'])
self.assertEqual("8/2018",
result.message["additionalData"]['expiryDate'])
self.assertEqual("GREEN",
result.message["additionalData"]['fraudResultType'])
def test_payments_error_mocked(self):
request = {
'amount': {
"value": "100000",
"currency": "EUR"
},
'reference': "54431",
'paymentMethod': {
"type": "scheme",
"number": "4111111111111111",
"expiryMonth": "08",
"expiryYear": "2018",
"holderName": "John Smith",
"cvc": "737"
},
'merchantAccount': "YourMerchantAccount",
'returnUrl': "https://your-company.com/..."
}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"payments-error"
"-invalid"
"-data-422"
".json")
result = self.adyen.checkout.payments(request)
self.adyen.client.http_client.request.assert_called_once_with(
'https://checkout-test.adyen.com/v67/payments',
headers={},
json={
'returnUrl': 'https://your-company.com/...',
u'applicationInfo': {
u'adyenLibrary': {
u'version': '5.1.0',
u'name': 'adyen-python-api-library'
}
},
'reference': '54431',
'merchantAccount': 'YourMerchantAccount',
'amount': {
'currency': 'EUR',
'value': '100000'
},
'paymentMethod': {
'expiryYear': '2018',
'holderName': 'John Smith',
'number': '4111111111111111',
'expiryMonth': '08',
'type': 'scheme',
'cvc': '737'
}
},
xapikey='YourXapikey')
self.assertEqual(422, result.message['status'])
self.assertEqual("130", result.message['errorCode'])
self.assertEqual("Reference Missing", result.message['message'])
self.assertEqual("validation", result.message['errorType'])
def test_payments_details_success_mocked(self):
request = {
'paymentData': "Hee57361f99....",
'details': {
"MD": "sdfsdfsdf...",
"PaRes": "sdkfhskdjfsdf..."
}
}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"paymentsdetails"
"-success.json")
result = self.adyen.checkout.payments_details(request)
self.adyen.client.http_client.request.assert_called_once_with(
u'https://checkout-test.adyen.com/v67/payments/details',
headers={},
json={
'paymentData': 'Hee57361f99....',
u'merchantAccount': None,
'details': {
'MD': 'sdfsdfsdf...',
'PaRes': 'sdkfhskdjfsdf...'
}
},
xapikey='YourXapikey')
self.assertEqual("8515232733321252", result.message['pspReference'])
self.assertEqual("Authorised", result.message['resultCode'])
self.assertEqual("true",
result.message['additionalData']['liabilityShift'])
self.assertEqual("AUTHORISED",
result.message['additionalData']['refusalReasonRaw'])
def test_payments_details_error_mocked(self):
request = {
'paymentData': "Hee57361f99....",
'details': {
"MD": "sdfsdfsdf...",
"PaRes": "sdkfhskdjfsdf..."
}
}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"paymentsdetails"
"-error-invalid-"
"data-422.json")
result = self.adyen.checkout.payments_details(request)
self.assertEqual(422, result.message['status'])
self.assertEqual("101", result.message['errorCode'])
self.assertEqual("Invalid card number", result.message['message'])
self.assertEqual("validation", result.message['errorType'])
def test_payments_session_success_mocked(self):
request = {
"reference": "Your order number",
"shopperReference": "yourShopperId_IOfW3k9G2PvXFu2j",
"channel": "iOS",
"token": "TOKEN_YOU_GET_FROM_CHECKOUT_SDK",
"returnUrl": "app://",
"countryCode": "NL",
"shopperLocale": "nl_NL",
"sessionValidity": "2017-04-06T13:09:13Z",
"merchantAccount": "YOUR_MERCHANT_ACCOUNT",
'amount': {
"value": "17408",
"currency": "EUR"
}
}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"paymentsession"
"-success.json")
result = self.adyen.checkout.payment_session(request)
self.assertIsNotNone(result.message['paymentSession'])
def test_payments_session_error_mocked(self):
request = {
"reference": "Your wro order number",
"shopperReference": "yourShopperId_IOfW3k9G2PvXFu2j",
"channel": "iOS",
"token": "WRONG_TOKEN",
"returnUrl": "app://",
"countryCode": "NL",
"shopperLocale": "nl_NL",
"sessionValidity": "2017-04-06T13:09:13Z",
"merchantAccount": "YOUR_MERCHANT_ACCOUNT",
'amount': {
"value": "17408",
"currency": "EUR"
}
}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"paymentsession"
"-error-invalid-"
"data-422.json")
result = self.adyen.checkout.payment_session(request)
self.assertEqual(422, result.message['status'])
self.assertEqual("14_012", result.message['errorCode'])
self.assertEqual("The provided SDK token could not be parsed.",
result.message['message'])
self.assertEqual("validation", result.message['errorType'])
def test_payments_result_success_mocked(self):
request = {"payload": "VALUE_YOU_GET_FROM_CHECKOUT_SDK"}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"paymentsresult"
"-success.json")
result = self.adyen.checkout.payment_result(request)
self.assertEqual("8535253563623704", result.message['pspReference'])
self.assertEqual("Authorised", result.message['resultCode'])
def test_payments_result_error_mocked(self):
request = {"payload": "VALUE_YOU_GET_FROM_CHECKOUT_SDK"}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"paymentsresult"
"-error-invalid-"
"data-payload-"
"422.json")
result = self.adyen.checkout.payment_result(request)
self.assertEqual(422, result.message['status'])
self.assertEqual("14_018", result.message['errorCode'])
self.assertEqual("Invalid payload provided", result.message['message'])
self.assertEqual("validation", result.message['errorType'])
def test_orders_success(self):
request = {'merchantAccount': "YourMerchantAccount"}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"orders"
"-success.json")
result = self.adyen.checkout.orders(request)
self.assertEqual("8515930288670953", result.message['pspReference'])
self.assertEqual("Success", result.message['resultCode'])
self.assertEqual("order reference", result.message['reference'])
self.assertEqual("EUR", result.message['remainingAmount']["currency"])
self.assertEqual(2500, result.message['remainingAmount']['value'])
def test_orders_cancel_success(self):
request = {'merchantAccount': "YourMerchantAccount"}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"orders-cancel"
"-success.json")
result = self.adyen.checkout.orders_cancel(request)
self.assertEqual("8515931182066678", result.message['pspReference'])
self.assertEqual("Received", result.message['resultCode'])
def test_paymentmethods_balance_success(self):
request = {'merchantAccount': "YourMerchantAccount"}
self.adyen.client = self.test.create_client_from_file(
200, request, "test/mocks/"
"checkout/"
"paymentmethods"
"-balance"
"-success.json")
result = self.adyen.checkout.payment_methods_balance(request)
self.assertEqual("851611111111713K", result.message['pspReference'])
self.assertEqual("Success", result.message['resultCode'])
self.assertEqual(100, result.message['balance']['value'])
self.assertEqual("EUR", result.message['balance']['currency'])
class TestModifications(unittest.TestCase):
ady = Adyen.Adyen()
client = ady.client
test = BaseTest(ady)
client.username = "******"
client.password = "******"
client.platform = "test"
def test_capture_success(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['modificationAmount'] = {"value": "1234", "currency": "EUR"}
request['originalReference'] = "YourOriginalReference"
self.ady.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'capture-success'
'.json')
result = self.ady.payment.capture(request)
self.assertEqual("[capture-received]", result.message['response'])
def test_capture_error_167(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['modificationAmount'] = {"value": "1234", "currency": "EUR"}
request['originalReference'] = "YourOriginalReference"
self.ady.client = self.test.create_client_from_file(
422, request, 'test/mocks/'
'capture-error-167'
'.json')
self.assertRaisesRegexp(Adyen.AdyenAPICommunicationError,
"Unexpected error", self.ady.payment.capture,
request)
def test_cancel_or_refund_received(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['originalReference'] = "YourOriginalReference"
self.ady.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'cancelOrRefund'
'-received.json')
result = self.ady.payment.cancel_or_refund(request)
self.assertEqual("[cancelOrRefund-received]",
result.message['response'])
def test_refund_received(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['originalReference'] = "YourOriginalReference"
request['modificationAmount'] = {"value": "1234", "currency": "EUR"}
self.ady.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'refund-received'
'.json')
result = self.ady.payment.refund(request)
self.assertEqual("[refund-received]", result.message['response'])
def test_cancel_received(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['originalReference'] = "YourOriginalReference"
self.ady.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'cancel-received'
'.json')
result = self.ady.payment.cancel(request)
self.assertEqual("[cancel-received]", result.message['response'])
def test_adjust_authorisation_received(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['modificationAmount'] = {"value": "1234", "currency": "EUR"}
request['originalReference'] = "YourOriginalReference"
self.ady.client = self.test.create_client_from_file(
200, request, 'test/mocks/'
'adjust-'
'authorisation-'
'received.json')
result = self.ady.payment.adjustAuthorisation(request)
self.assertEqual("[adjustAuthorisation-received]",
result.message['response'])
class TestBinLookup(unittest.TestCase):
ady = Adyen.Adyen()
client = ady.client
test = BaseTest(ady)
client.username = "******"
client.password = "******"
client.platform = "test"
def test_get_cost_estimate_success(self):
self.ady.client.http_client.request.reset_mock()
expected = {
'cardBin': {
'bin': '458012',
'commercial': False,
'fundingSource': 'CHARGE',
'fundsAvailability': 'N',
'issuingBank': 'Bank Of America',
'issuingCountry': 'US',
'issuingCurrency': 'USD',
'paymentMethod': 'Y',
'summary': '6789'
},
'costEstimateAmount': {
'currency': 'USD',
'value': 1234
},
'resultCode': 'Success',
'surchargeType': 'PASSTHROUGH'
}
self.ady.client = self.test.create_client_from_file(
status=200,
request=REQUEST_KWARGS,
filename='test/mocks/binlookup/getcostestimate-success.json')
result = self.ady.binlookup.get_cost_estimate(REQUEST_KWARGS)
self.assertEqual(expected, result.message)
self.ady.client.http_client.request.assert_called_once_with(
'https://pal-test.adyen.com/pal/servlet/'
'BinLookup/v50/getCostEstimate',
headers={},
json={
'merchantAccount': 'YourMerchantAccount',
'amount': '1000',
'applicationInfo': {
'adyenLibrary': {
'name': 'adyen-python-api-library',
'version': ANY
}
}
},
password='******',
username='******')
def test_get_cost_estimate_error_mocked(self):
self.ady.client = self.test.create_client_from_file(
status=200,
request=REQUEST_KWARGS,
filename=("test/mocks/binlookup/"
"getcostestimate-error-invalid-data-422.json"))
result = self.ady.binlookup.get_cost_estimate(REQUEST_KWARGS)
self.assertEqual(422, result.message['status'])
self.assertEqual("101", result.message['errorCode'])
self.assertEqual("Invalid card number", result.message['message'])
self.assertEqual("validation", result.message['errorType'])
def adyen_payments(frontend_request):
adyen = Adyen.Adyen()
adyen.client.platform = 'test'
adyen.client.xapikey = config.checkout_apikey
payment_info = frontend_request.get_json()
txvariant = payment_info["paymentMethod"]["type"]
order_ref = str(uuid.uuid4())
payments_request = {
'amount': {
'value': 1000,
'currency': choose_currency(txvariant)
},
'channel': 'Web',
'reference': order_ref,
'shopperReference': "Python Checkout Shopper",
'returnUrl':
"http://*****:*****@adyen.com"
payments_request['lineItems'] = [{
'quantity': "1",
'amountExcludingTax': "450",
'taxPercentage': "1111",
'description': "Sunglasses",
'id': "Item #1",
'taxAmount': "50",
'amountIncludingTax': "500",
'taxCategory': "High"
}, {
'quantity': "1",
'amountExcludingTax': "450",
'taxPercentage': "1111",
'description': "Headphones",
'id': "Item #2",
'taxAmount': "50",
'amountIncludingTax': "500",
'taxCategory': "High"
}]
elif txvariant == 'directEbanking' or txvariant == 'giropay':
payments_request['countryCode'] = "DE"
elif txvariant == 'dotpay':
payments_request['countryCode'] = "PL"
elif txvariant == 'scheme':
payments_request['additionalData'] = {"allow3DS2": "true"}
payments_request['origin'] = "http://localhost:8080"
elif txvariant == 'ach' or txvariant == 'paypal':
payments_request['countryCode'] = 'US'
print("/payments request:\n" + str(payments_request))
payments_response = adyen.checkout.payments(payments_request)
if "paymentData" in payments_response.message:
from app import payment_data_store
payment_data_store[order_ref] = payments_response.message[
"paymentData"]
print("/payments response:\n" +
payments_response.raw_response.decode("UTF-8"))
return payments_response.raw_response
import Adyen ady = Adyen.Adyen() """ Capture a Payment using Python Library Authorised (card) payments can be captured to get the money from the shopper. Payments can be automatically captured by our platform. A payment can also be captured by performing an API call. In order to capture an authorised (card) payment you have to send a modification request. This file shows how an authorised payment should be captured by sending a modification request using Python Library. Please note: using our API requires a web service user. Set up your Webservice user: Adyen Test CA >> Settings >> Users >> ws@Company. >> Generate Password >> Submit @link Modifications/Library/Capture.py @author Created by Adyen - Payments Made Easy """ """ Client settings - Adyen.client - username : your web service user - password : your web service user's password - platform : the environment you are using (test/live) - app_name : your application name """ client = ady.client client.username = "******" client.password = "******"
class TestModifications(unittest.TestCase):
ady = Adyen.Adyen()
client = ady.client
test = BaseTest(ady)
client.username = "******"
client.password = "******"
client.platform = "test"
client.app_name = "appname"
def test_capture_success(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['modificationAmount'] = {"value": "1234", "currency": "EUR"}
request['originalReference'] = "YourOriginalReference"
self.ady.client = self.test.create_client_from_file(200, request,
'test/mocks/'
'capture-success'
'.json')
result = self.ady.payment.capture(request)
self.assertEqual("[capture-received]", result.message['response'])
def test_capture_error_167(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['modificationAmount'] = {"value": "1234", "currency": "EUR"}
request['originalReference'] = "YourOriginalReference"
self.ady.client = self.test.create_client_from_file(422, request,
'test/mocks/'
'capture-error-167'
'.json')
self.assertRaisesRegexp(Adyen.AdyenAPIValidationError,
"Received validation error with errorCode:"
" 167, message: Original pspReference required"
" for this operation, HTTP Code: 422." +
" Please verify the values provided. Please "
"reach out to [email protected] if the problem"
" persists, providing the PSP reference.*",
self.ady.payment.capture, request)
def test_cancel_or_refund_received(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['originalReference'] = "YourOriginalReference"
self.ady.client = self.test.create_client_from_file(200, request,
'test/mocks/'
'cancelOrRefund'
'-received.json')
result = self.ady.payment.cancel_or_refund(request)
self.assertEqual("[cancelOrRefund-received]",
result.message['response'])
def test_refund_received(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['originalReference'] = "YourOriginalReference"
request['modificationAmount'] = {"value": "1234", "currency": "EUR"}
self.ady.client = self.test.create_client_from_file(200, request,
'test/mocks/'
'refund-received'
'.json')
result = self.ady.payment.refund(request)
self.assertEqual("[refund-received]", result.message['response'])
def test_cancel_received(self):
request = {}
request['merchantAccount'] = "YourMerchantAccount"
request['reference'] = "YourReference"
request['originalReference'] = "YourOriginalReference"
self.ady.client = self.test.create_client_from_file(200, request,
'test/mocks/'
'cancel-received'
'.json')
result = self.ady.payment.cancel(request)
self.assertEqual("[cancel-received]", result.message['response'])
import Adyen
ady = Adyen.Adyen()
client = ady.client
client.xapikey = "AQElhmfuXNWTK0Qc+iSUk2o7orCXQY1I3wEMlJngVegxueSC9koTlxDBXVsNvuR83LVYjEgiTGAH-wfG1CRJ3jahhXUCsu6Fe33WKr21rljDeU6Tfp0NS9Ls=-P*Mn8bjD,4j8Ih2b"
client.platform = "test"
adyen = Adyen.Adyen()
adyen.client.xapikey = 'AQElhmfuXNWTK0Qc+iSUk2o7orCXQY1I3wEMlJngVegxueSC9koTlxDBXVsNvuR83LVYjEgiTGAH-wfG1CRJ3jahhXUCsu6Fe33WKr21rljDeU6Tfp0NS9Ls=-P*Mn8bjD,4j8Ih2b'
result = adyen.checkout.payment_methods({
'merchantAccount': 'Dance4lifeECOM',
'countryCode': 'NL',
'amount': {
'value': 1000,
'currency': 'EUR'
},
'channel': 'Web',
})
print(result)
adyen = Adyen.Adyen()
adyen.client.xapikey = 'AQElhmfuXNWTK0Qc+iSUk2o7orCXQY1I3wEMlJngVegxueSC9koTlxDBXVsNvuR83LVYjEgiTGAH-wfG1CRJ3jahhXUCsu6Fe33WKr21rljDeU6Tfp0NS9Ls=-P*Mn8bjD,4j8Ih2b'
result = adyen.checkout.payments({
'amount': {
'value': 1000,
'currency': 'EUR'
},
'reference': '123',
'paymentMethod': {