def test_token(self): billing_address = Address() billing_address.country_code = "NL" customer = CustomerToken() customer.billing_address = billing_address card_without_ccv = CardWithoutCvv() card_without_ccv.cardholder_name = "Jan" card_without_ccv.issue_number = "12" card_without_ccv.card_number = "4567350000427977" card_without_ccv.expiry_date = "0820" card_data = TokenCardData() card_data.card_without_cvv = card_without_ccv card = TokenCard() card.customer = customer card.data = card_data create_token_request = CreateTokenRequest() create_token_request.payment_product_id = 1 create_token_request.card = card with init_utils.create_client() as client: token_response = client.merchant(MERCHANT_ID).tokens().create( create_token_request) self.assertIsNotNone(token_response.token) client.merchant(MERCHANT_ID).tokens().delete( token_response.token, DeleteTokenParams())
def test_payment_products(self): """Test if products function""" params = FindProductsParams() params.country_code = "NL" params.currency_code = "EUR" with init_utils.create_client() as client: response = client.merchant(MERCHANT_ID).products().find(params) self.assertGreater(len(response.payment_products), 0)
def test_payment_product_groups(self): """Test if product groups function""" params = GetProductgroupParams() params.country_code = "NL" params.currency_code = "EUR" with init_utils.create_client() as client: response = client.merchant(MERCHANT_ID).productgroups().get( "cards", params) self.assertEqual("cards", response.id)
def test_payment_product_directories(self): """Test if product directories function""" params = DirectoryParams() params.country_code = "NL" params.currency_code = "EUR" with init_utils.create_client() as client: response = client.merchant(MERCHANT_ID).products().directory( 809, params) self.assertGreater(len(response.entries), 0)
def test_payment_product_groups(self): """Test if product groups function""" params = GetProductGroupsParams() params.country_code = "BE" params.currency_code = "EUR" with init_utils.create_client() as client: response = client.merchant(MERCHANT_ID).product_groups().get_product_groups(params) self.assertIsNotNone(response.payment_product_groups) self.assertGreater(len(response.payment_product_groups), 0)
def test_convert_amount(self): """Test if the convert amount service can connect to the server""" request = ConvertAmountParams() request.amount = 123L request.source = "USD" request.target = "EUR" with init_utils.create_client() as client: response = client.merchant(MERCHANT_ID).services().convert_amount( request) # actual convert amount may vary due to changing rates, so simply check if there is an amount self.assertIsNotNone(response.converted_amount) self.assertGreater(int(response.converted_amount), 0)
def test_idempotence(self): """Test that the client can successfully detect that an idempotent request is sent twice""" amount_of_money = AmountOfMoney() amount_of_money.currency_code = "EUR" amount_of_money.amount = 100L billing_address = Address() billing_address.country_code = "NL" customer = Customer() customer.locale = "en" customer.billing_address = billing_address order = Order() order.amount_of_money = amount_of_money order.customer = customer payment_product_input = RedirectPaymentProduct809SpecificInput() payment_product_input.issuer_id = "INGBNL2A" payment_method_input = RedirectPaymentMethodSpecificInput() payment_method_input.return_url = "http://example.com" payment_method_input.payment_product_id = 809 payment_method_input.payment_product809_specific_input = payment_product_input body = CreatePaymentRequest() body.order = order body.redirect_payment_method_specific_input = payment_method_input idempotence_key = str(uuid.uuid4()) context = CallContext(idempotence_key) with init_utils.create_client() as client: def do_create_payment(): # For this test it doesn't matter if the response is successful or declined, # as long as idempotence is handled correctly try: return client.merchant(MERCHANT_ID).payments().create(body, context) except DeclinedPaymentException as e: return e.create_payment_result result = do_create_payment() payment_id = result.payment.id status = result.payment.status self.assertEqual(idempotence_key, context.idempotence_key) self.assertIsNone(context.idempotence_request_timestamp) result_2 = do_create_payment() payment_id_2 = result_2.payment.id status_2 = result_2.payment.status self.assertEqual(payment_id, payment_id_2) self.assertEqual(status, status_2) self.assertEqual(idempotence_key, context.idempotence_key) self.assertIsNotNone(context.idempotence_request_timestamp)
def test_idempotence(self): """Test that the client can successfully detect that an idempotent request is sent twice""" amount_of_money = AmountOfMoney() amount_of_money.currency_code = "EUR" amount_of_money.amount = 100 billing_address = Address() billing_address.country_code = "BE" customer = Customer() customer.locale = "en" customer.billing_address = billing_address order = Order() order.amount_of_money = amount_of_money order.customer = customer card = Card() card.card_number = "4567350000427977" card.cardholder_name = "Wile E. Coyote" card.cvv = "123" card.expiry_date = "1234" payment_method_input = CardPaymentMethodSpecificInput() payment_method_input.return_url = "http://example.com" payment_method_input.payment_product_id = 1 payment_method_input.card = card body = CreatePaymentRequest() body.order = order body.card_payment_method_specific_input = payment_method_input idempotence_key = str(uuid.uuid4()) context = CallContext(idempotence_key) with init_utils.create_client() as client: response = client.merchant(MERCHANT_ID).payments().create_payment( body, context) payment_id = response.payment.id self.assertEqual(idempotence_key, context.idempotence_key) self.assertIsNone(context.idempotence_request_timestamp) response_2 = client.merchant( MERCHANT_ID).payments().create_payment(body, context) payment_id_2 = response_2.payment.id self.assertEqual(payment_id, payment_id_2) self.assertEqual(idempotence_key, context.idempotence_key) self.assertIsNotNone(context.idempotence_request_timestamp)
def test_idempotence(self): """Test that the client can successfully detect that an idempotent request is sent twice""" amount_of_money = AmountOfMoney() amount_of_money.currency_code = "EUR" amount_of_money.amount = 100L billing_address = Address() billing_address.country_code = "NL" customer = Customer() customer.locale = "en" customer.billing_address = billing_address order = Order() order.amount_of_money = amount_of_money order.customer = customer payment_product_input = RedirectPaymentProduct809SpecificInput() payment_product_input.issuer_id = "INGBNL2A" payment_method_input = RedirectPaymentMethodSpecificInput() payment_method_input.return_url = "http://example.com" payment_method_input.payment_product_id = 809 payment_method_input.payment_product809_specific_input = payment_product_input body = CreatePaymentRequest() body.order = order body.redirect_payment_method_specific_input = payment_method_input idempotence_key = str(uuid.uuid4()) context = CallContext(idempotence_key) with init_utils.create_client() as client: response = client.merchant(MERCHANT_ID).payments().create( body, context) payment_id = response.payment.id self.assertEqual(idempotence_key, context.idempotence_key) self.assertIsNone(context.idempotence_request_timestamp) response_2 = client.merchant(MERCHANT_ID).payments().create( body, context) payment_id_2 = response_2.payment.id self.assertEqual(payment_id, payment_id_2) self.assertEqual(idempotence_key, context.idempotence_key) self.assertIsNotNone(context.idempotence_request_timestamp)
def test_risk_assessments(self): """Test if the risk assessments service functions""" bank_account_bban = BankAccountBban() bank_account_bban.country_code = "DE" bank_account_bban.account_number = "0532013000" bank_account_bban.bank_code = "37040044" amount_of_money = AmountOfMoney() amount_of_money.amount = 100 amount_of_money.currency_code = "EUR" customer = CustomerRiskAssessment() customer.locale = "en_GB" order = OrderRiskAssessment() order.amount_of_money = amount_of_money order.customer = customer body = RiskAssessmentBankAccount() body.order = order body.bank_account_bban = bank_account_bban with init_utils.create_client() as client: response = client.merchant( MERCHANT_ID).riskassessments().bankaccounts(body) self.assertGreater(len(response.results), 0)
def test_services(self): with init_utils.create_client() as client: response = client.merchant( MERCHANT_ID).services().test_connection() self.assertIsNotNone(response.result)