def test_create():
transaction.create(transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
default_recipient_id = transaction_dictionary.DEFAULT_RECIPIENT
recipient.update_recipient(default_recipient_id,
recipient_dictionary.UPDATE_RECIPIENT)
_bulk_anticipation = bulk_anticipation.create(
default_recipient_id, bulk_anticipation_dictionary.BULK_ANTICIPATION)
assert _bulk_anticipation['id'] is not None
def test_refund_transaction(retry):
trx_boleto = transaction.create(transaction_dictionary.BOLETO_TRANSACTION)
transaction.pay_boleto(trx_boleto['id'], transaction_dictionary.PAY_BOLETO)
trx_credit_card = transaction.create(transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
refund_transaction = transaction.refund(trx_credit_card['id'], transaction_dictionary.REFUNDED_OR_CAPTURE_TRANSACTION)
search_params = {'id': str(refund_transaction['id'])}
refunded_transaction = retry(lambda: transaction.find_by(search_params))
assert 'refunded' == refunded_transaction[0]['status']
def test_find_all():
transaction.create(transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
default_recipient_id = transaction_dictionary.DEFAULT_RECIPIENT
recipient.update_recipient(default_recipient_id,
recipient_dictionary.UPDATE_RECIPIENT)
_bulk_anticipation = bulk_anticipation.create(
default_recipient_id, bulk_anticipation_dictionary.BULK_ANTICIPATION)
all_bulk_anticipations = bulk_anticipation.find_all(default_recipient_id)
assert all_bulk_anticipations[0]['id'] == _bulk_anticipation['id']
def test_confirm():
transaction.create(transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
default_recipient_id = transaction_dictionary.DEFAULT_RECIPIENT
recipient.update_recipient(default_recipient_id,
recipient_dictionary.UPDATE_RECIPIENT)
_bulk_anticipation = bulk_anticipation.create(
default_recipient_id, bulk_anticipation_dictionary.BULK_ANTICIPATION)
confirm_bulk_anticipation = bulk_anticipation.confirm(
default_recipient_id, _bulk_anticipation['id'])
assert confirm_bulk_anticipation['status'] == 'pending'
def test_refunds():
trx = transaction.create(
transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
transaction.refund(trx['id'],
transaction_dictionary.REFUNDED_OR_CAPTURE_TRANSACTION)
refunds = refund.refunds()
assert refunds[0]['status'] == 'refunded'
def test_find_specific_payable():
trx = transaction.create(
transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
all_payables = transaction.payables(trx['id'])
specific_payable = transaction.specific_payable(trx['id'],
all_payables[0]['id'])
assert specific_payable['id'] is not None
def test_create_transfer():
boleto = transaction.create(transaction_dictionary.BOLETO_TRANSACTION_SPLIT_RULE_PERCENTAGE)
transaction.pay_boleto(boleto['id'], transaction_dictionary.PAY_BOLETO)
transfer_dictionary.TRANSFER['recipient_id'] = \
transaction_dictionary.BOLETO_TRANSACTION_SPLIT_RULE_PERCENTAGE['split_rules'][0]['recipient_id']
_transfer = transfer.create(transfer_dictionary.TRANSFER)
assert _transfer['id'] is not None
def one_click_buy(payment_item_config_slug: PagarmeItemConfig, user):
"""
Create Transaction
https://docs.pagar.me/reference#criar-transacao
"""
item = get_payment_item(payment_item_config_slug)
form_config = item.default_config
profile = get_user_payment_profile(user)
domain = settings.ALLOWED_HOSTS[0]
notification_path = reverse('django_pagarme:notification',
kwargs={'slug': item.slug})
postback_url = f'https://{domain}{notification_path}'
payment_data = {
'amount': item.price,
'card_id': profile.card_id,
'payment_method': 'credit_card',
'postback_url': postback_url,
'async': False,
'installments': form_config.max_installments,
'soft_descriptor': 'pythopro',
'capture': True,
'customer': profile.to_customer_api_dict(),
'billing': profile.to_billing_dict(),
'items': [item.to_dict()]
}
return transaction.create(payment_data)
def test_find_by():
trx = transaction.create(
transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
time.sleep(1)
search_params = {'id': trx['id']}
find_trx = transaction.find_by(search_params)
assert trx['id'] == find_trx[0]['id']
def test_find_all_postbacks(retry):
_transaction = transaction.create(transaction_dictionary.BOLETO_TRANSACTION)
transaction.pay_boleto(_transaction['id'], transaction_dictionary.PAY_BOLETO)
search_params = {'id': _transaction['id']}
_transaction_paid = retry(lambda: transaction.find_by(search_params))
_postbacks = transaction.postbacks(_transaction_paid[0]['id'])
assert _postbacks[0]['model_id'] == str(_transaction_paid[0]['id'])
def test_specific_postback(retry):
_transaction = transaction.create(transaction_dictionary.BOLETO_TRANSACTION)
transaction.pay_boleto(_transaction['id'], transaction_dictionary.PAY_BOLETO)
search_params = {'id': _transaction['id']}
transaction_paid = retry(lambda: transaction.find_by(search_params))
postbacks = transaction.postbacks(transaction_paid[0]['id'])
specific_postback = transaction.specific_postback(transaction_paid[0]['id'], postbacks[0]['id'])
assert specific_postback['id'] == postbacks[0]['id']
def test_postbacks_redeliver(retry):
_transaction = transaction.create(transaction_dictionary.BOLETO_TRANSACTION)
transaction.pay_boleto(_transaction['id'], transaction_dictionary.PAY_BOLETO)
search_params = {'id': _transaction['id']}
_transaction_paid = retry(lambda: transaction.find_by(search_params))
_postbacks = transaction.postbacks(_transaction_paid[0]['id'])
redeliver = transaction.postback_redeliver(_transaction_paid[0]['id'], _postbacks[0]['id'])
assert redeliver['status'] == 'pending_retry'
def test_recipient_balance_operation():
boleto = transaction.create(transaction_dictionary.BOLETO_TRANSACTION_SPLIT_RULE_PERCENTAGE)
transaction.pay_boleto(boleto['id'], transaction_dictionary.PAY_BOLETO)
transfer_dictionary.TRANSFER['recipient_id'] = \
transaction_dictionary.BOLETO_TRANSACTION_SPLIT_RULE_PERCENTAGE['split_rules'][0]['recipient_id']
_transfer = transfer.create(transfer_dictionary.TRANSFER)
recipient_balance_operation = recipient.recipient_balance_operation(_transfer['source_id'])
assert recipient_balance_operation[0]['movement_object']['source_id'] == _transfer['source_id']
def test_find_all():
boleto = transaction.create(
transaction_dictionary.BOLETO_TRANSACTION_SPLIT_RULE_PERCENTAGE)
transaction.pay_boleto(boleto['id'], transaction_dictionary.PAY_BOLETO)
transfer_dictionary.TRANSFER['recipient_id'] = \
transaction_dictionary.BOLETO_TRANSACTION_SPLIT_RULE_PERCENTAGE['split_rules'][0]['recipient_id']
transfer.create(transfer_dictionary.TRANSFER)
balance_operations = balance_operation.find_all()
assert balance_operations is not None
def test_find_by():
boleto = transaction.create(transaction_dictionary.BOLETO_TRANSACTION_SPLIT_RULE_PERCENTAGE)
transaction.pay_boleto(boleto['id'], transaction_dictionary.PAY_BOLETO)
transfer_dictionary.TRANSFER['recipient_id'] = \
transaction_dictionary.BOLETO_TRANSACTION_SPLIT_RULE_PERCENTAGE['split_rules'][0]['recipient_id']
_transfer = transfer.create(transfer_dictionary.TRANSFER)
search_params = {'id': str(_transfer['id'])}
find_transfer = transfer.find_by(search_params)
assert _transfer['id'] == find_transfer[0]['id']
def test_find_by():
boleto = transaction.create(
transaction_dictionary.BOLETO_TRANSACTION_SPLIT_RULE_PERCENTAGE)
transaction.pay_boleto(boleto['id'], transaction_dictionary.PAY_BOLETO)
transfer_dictionary.TRANSFER['recipient_id'] = \
transaction_dictionary.BOLETO_TRANSACTION_SPLIT_RULE_PERCENTAGE['split_rules'][0]['recipient_id']
transfer.create(transfer_dictionary.TRANSFER)
find_all = balance_operation.find_all()
search_params = {'id': find_all[0]['id']}
find_balance_operation = balance_operation.find_by(search_params)
assert find_balance_operation[0]['id'] == find_all[0]['id']
def test_find_all_transaction_payables():
trx = transaction.create(
transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
all_payables = transaction.payables(trx['id'])
assert all_payables is not None
def test_error_request():
error = transaction.create(transaction_dictionary.INVALID_REQUEST)
assert error[0]['type'] == 'invalid_parameter'
def test_find_all_transaction_operations():
trx = transaction.create(
transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
all_operations = transaction.operations(trx['id'])
assert all_operations[0]['id'] is not None
def test_create_transaction_with_split_rule_amount():
trx = transaction.create(
transaction_dictionary.
VALID_CREDIT_CARD_TRANSACTION_WITH_SPLIT_RULE_AMOUNT)
assert trx['split_rules'] is not None
def test_create_transaction_with_split_rule_percentage():
trx = transaction.create(
transaction_dictionary.
VALID_CREDIT_CARD_TRANSACTION_WITH_SPLIT_RULE_PERCENTAGE)
assert trx['split_rules'] is not None
def test_capture_transaction():
trx = transaction.create(
transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION_CAPTURE_FALSE)
capture_transaction = transaction.capture(
trx['id'], transaction_dictionary.REFUNDED_OR_CAPTURE_TRANSACTION)
assert 'paid' == capture_transaction['status']
def test_create_transaction():
trx = transaction.create(
transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
assert trx['id'] is not None
def test_pay_boleto():
trx = transaction.create(transaction_dictionary.BOLETO_TRANSACTION)
pay_transaction = transaction.pay_boleto(trx['id'],
transaction_dictionary.PAY_BOLETO)
assert 'paid' == pay_transaction['status']
def test_find_by_id():
trx = transaction.create(transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
time.sleep(3)
found_trx = transaction.find_by_id(trx['id'])
assert trx['id'] == found_trx['id']
def pay(self, card_index=0):
self.client.validate_customer()
self.client.validate_cards()
self.validate_recipient()
if not hasattr(self.client, 'address'):
raise ValidationError('The user address is required')
if not self.paid:
billing_fields = [
'zipcode', 'street', 'street_number', 'state', 'city',
'neighborhood'
]
address = model_to_dict(instance=self.client.address,
fields=billing_fields)
address['zipcode'] = re.sub('[^0-9]', '', address.get('zipcode'))
default_recipient = pagarme.recipient.default_recipient()
recipient_status = 'live' if settings.PRODUCTION else 'test'
comission = settings.PLATFORM_COMMISSION or 0
customer = {
'external_id': str(self.client.uuid),
'name': self.client.full_name,
'email': self.client.email,
'country': 'br',
'type': 'individual',
'phone_numbers': self.client.customer['phone_numbers'],
'documents': [{
'type': 'cpf',
'number': self.client.unmasked_cpf
}],
}
data = {
'amount':
int(self.value * 100),
'card_id':
self.client.cards[card_index]['id'],
'customer':
customer,
'payment_method':
'credit_card',
'async':
False,
'postback_url':
self.postback_url,
'soft_descriptor':
settings.PAYMENT_DESCRIPTION,
'billing': {
'name': self.client.full_name,
'address': {
**address, 'country': 'br'
}
},
'items': [{
'id': str(self.job.uuid),
'title': self.job.proposal.description,
'unit_price': int(self.value * 100),
'quantity': 1,
'tangible': False,
'category': 'Services',
'date': self.job.start_datetime.date().isoformat()
}],
'metadata': {
'payment': str(self.uuid),
'job': str(self.job.uuid),
'professional': self.professional.user.full_name,
'client': self.client.full_name,
},
'split_rules': [
{
'recipient_id':
default_recipient.get(recipient_status),
'charge_processing_fee': True,
'percentage': comission,
'charge_remainder_fee': True,
},
{
'recipient_id': self.professional.recipient['id'],
'charge_processing_fee': False,
'percentage': (100 - (comission)),
'charge_remainder_fee': False,
},
]
}
self.__transaction = transaction.create(data)
if self.__transaction.get('status', None) == 'paid':
self.paid = True
self.pagarme_id = self.__transaction.get('id')
self.save(update_fields=['paid', 'pagarme_id'])
return self.transaction
def test_error_request():
with pytest.raises(Exception) as PagarMeException:
transaction.create(transaction_dictionary.INVALID_REQUEST)
assert 'valor' in str(PagarMeException.value)
def test_find_by(retry):
trx = transaction.create(transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
search_params = {'id': trx['id']}
find_trx = retry(lambda: transaction.find_by(search_params))
assert trx['id'] == find_trx[0]['id']
def test_find_by_id(retry):
trx = transaction.create(transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
found_trx = retry(lambda: transaction.find_by_id(trx['id']))
assert trx['id'] == found_trx['id']
from pagarme import transaction
from tests.resources.dictionaries import transaction_dictionary
TRANSACTION = transaction.create(
transaction_dictionary.VALID_CREDIT_CARD_TRANSACTION)
PAYABLES = transaction.payables(TRANSACTION['id'])
