def test_no_transaction_settle_with_only_related_proforma(self):
proforma = ProformaFactory.create(related_document=None)
customer = proforma.customer
PaymentMethodFactory.create(
payment_processor=triggered_processor,
customer=customer,
canceled=False,
verified=True,
)
proforma.issue()
transaction = proforma.transactions[0]
# here transaction.proforma is the same object as the proforma from the
# DB due to the way transition callbacks and saves are called
transaction.settle()
transaction.save()
self.assertEqual(proforma.state, proforma.STATES.PAID)
invoice = proforma.related_document
self.assertEqual(invoice.state, invoice.STATES.PAID)
self.assertEqual(list(proforma.transactions),
list(invoice.transactions))
self.assertEqual(len(proforma.transactions), 1)
def test_no_transaction_settle_with_only_related_proforma(self):
proforma = ProformaFactory.create(related_document=None)
customer = proforma.customer
PaymentMethodFactory.create(
payment_processor=triggered_processor, customer=customer,
canceled=False,
verified=True,
)
proforma.issue()
transaction = proforma.transactions[0]
# here transaction.proforma is the same object as the proforma from the
# DB due to the way transition callbacks and saves are called
transaction.settle()
transaction.save()
self.assertEqual(proforma.state, proforma.STATES.PAID)
invoice = proforma.related_document
self.assertEqual(invoice.state, invoice.STATES.PAID)
self.assertEqual(list(proforma.transactions),
list(invoice.transactions))
self.assertEqual(len(proforma.transactions), 1)
def test_get_listing(self):
PaymentMethodFactory.create(customer=CustomerFactory.create())
payment_method = self.create_payment_method(customer=self.customer)
url = reverse('payment-method-list',
kwargs={'customer_pk': self.customer.pk})
self.assert_get_data(url, [payment_method])
def test_get_listing(self):
PaymentMethodFactory.create(customer=CustomerFactory.create())
payment_method = self.create_payment_method(customer=self.customer)
url = reverse('payment-method-list', kwargs={
'customer_pk': self.customer.pk
})
self.assert_get_data(url, [payment_method])
def test_get_detail(self):
PaymentMethodFactory.create(customer=CustomerFactory.create())
payment_method = self.create_payment_method(customer=self.customer)
url = reverse('payment-method-detail', kwargs={
'customer_pk': self.customer.pk,
'payment_method_id': payment_method.pk
})
self.assert_get_data(url, payment_method)
def test_get_detail(self):
PaymentMethodFactory.create(customer=CustomerFactory.create())
payment_method = self.create_payment_method(customer=self.customer)
url = reverse('payment-method-detail', kwargs={
'customer_pk': self.customer.pk,
'payment_method_id': payment_method.pk
})
self.assert_get_data(url, payment_method)
def test_patch_transaction_not_allowed_fields(self):
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor)
customer = payment_method.customer
transaction = TransactionFactory.create(payment_method=payment_method)
proforma = ProformaFactory.create(state='issued', customer=customer)
invoice = InvoiceFactory.create(state='issued',
customer=customer,
related_document=proforma)
proforma.related_document = invoice
proforma.save()
invoice_url = reverse('invoice-detail', args=[invoice.pk])
proforma_url = reverse('proforma-detail', args=[proforma.pk])
url = reverse('transaction-detail',
args=[transaction.customer.pk, transaction.uuid])
new_payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor, customer=customer)
new_payment_method_url = reverse('payment-method-detail',
kwargs={
'customer_pk':
new_payment_method.customer.pk,
'payment_method_id':
new_payment_method.pk
})
data = {
'proforma': proforma_url,
'invoice': invoice_url,
'currency': 'EUR',
'amount': 1234,
'payment_method': new_payment_method_url
}
response = self.client.patch(url, format='json', data=data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
print(response.data)
self.assertEqual(
response.data, {
'proforma': [u'This field may not be modified.'],
'invoice': [u'This field may not be modified.'],
'currency': [u'This field may not be modified.'],
'amount': [u'This field may not be modified.'],
'payment_method': [u'This field may not be modified.']
})
def test_add_transaction_with_documents_for_a_different_customer(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
proforma = ProformaFactory.create()
proforma.issue()
proforma.create_invoice()
proforma.refresh_from_db()
invoice = proforma.related_document
valid_until = datetime.now().replace(microsecond=0)
url = reverse('payment-method-transaction-list',
kwargs={'customer_pk': customer.pk,
'payment_method_id': payment_method.pk})
invoice_url = reverse('invoice-detail', args=[invoice.pk])
proforma_url = reverse('proforma-detail', args=[proforma.pk])
data = {
'payment_method': reverse('payment-method-detail',
kwargs={'customer_pk': customer.pk,
'payment_method_id': payment_method.id}),
'valid_until': valid_until,
'amount': 200.0,
'invoice': invoice_url,
'proforma': proforma_url
}
response = self.client.post(url, format='json', data=data)
expected_data = {
'non_field_errors': [u"Customer doesn't match with the one in documents."]
}
self.assertEqual(response.data, expected_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_add_transaction_with_amount_greater_than_what_should_be_charged(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
proforma = ProformaFactory.create(customer=customer,
state=Proforma.STATES.ISSUED,
issue_date=timezone.now().date())
proforma.create_invoice()
invoice = proforma.related_document
valid_until = datetime.now().replace(microsecond=0)
url = reverse('payment-method-transaction-list',
kwargs={'customer_pk': customer.pk,
'payment_method_id': payment_method.pk})
invoice_url = reverse('invoice-detail', args=[invoice.pk])
proforma_url = reverse('proforma-detail', args=[proforma.pk])
data = {
'payment_method': reverse('payment-method-detail',
kwargs={'customer_pk': customer.pk,
'payment_method_id': payment_method.id}),
'valid_until': valid_until,
'amount': invoice.total_in_transaction_currency + 1,
'invoice': invoice_url,
'proforma': proforma_url
}
response = self.client.post(url, format='json', data=data)
expected_data = {
'non_field_errors': ["Amount is greater than the amount that should be charged in "
"order to pay the billing document."]
}
self.assertEqual(response.data, expected_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_create_one_without_required_fields(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
payment = PaymentFactory.create(customer=customer)
transaction = TransactionFactory.create(payment_method=payment_method,
payment=payment)
valid_until = datetime.now()
url = reverse('transaction-detail',
kwargs={
'customer_pk': customer.id,
'transaction_uuid': transaction.uuid
})
data = {
'payment':
reverse('payment-detail',
kwargs={
'customer_pk': customer.id,
'payment_pk': payment.id
}),
'valid_until':
valid_until
}
url = reverse('payment-method-transaction-list',
kwargs={
'customer_pk': customer.id,
'payment_method_id': payment_method.id
})
response = self.client.post(url, format='json', data=data)
self.assertEqual(response.data['payment_method'],
['This field is required.'])
def test_add_transaction_without_documents(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
valid_until = datetime.now().replace(microsecond=0)
url = reverse('payment-method-transaction-list',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.pk
})
data = {
'payment_method':
reverse('payment-method-detail',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.id
}),
'valid_until':
valid_until,
'amount':
200.0,
}
response = self.client.post(url, format='json', data=data)
expected_data = {
'non_field_errors': [
u'The transaction must have at '
u'least one document (invoice or proforma).'
]
}
self.assertEqual(response.data, expected_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_fetch_transaction_status_transactions_filtering(self):
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor
)
transactions = TransactionFactory.create_batch(
5, payment_method=payment_method, state=Transaction.States.Pending
)
filtered_transactions = [
transactions[0], transactions[2], transactions[4]
]
mock_fetch_status = MagicMock()
with patch.multiple(TriggeredProcessor,
fetch_transaction_status=mock_fetch_status):
transactions_arg = [
str(transaction.pk) for transaction in filtered_transactions
]
call_command('fetch_transactions_status',
'--transactions=%s' % ','.join(transactions_arg))
for transaction in filtered_transactions:
self.assertIn(call(transaction),
mock_fetch_status.call_args_list)
self.assertEqual(mock_fetch_status.call_count,
len(filtered_transactions))
def test_create_negative_document(self):
""" Confirm that an invoice can be issued with a negative value. """
# 0 for easy asserting.
customer = CustomerFactory(sales_tax_percent=0, currency='USD')
entry = DocumentEntryFactory(quantity=1, unit_price=-150)
invoice = InvoiceFactory.create(invoice_entries=[entry],
customer=customer)
invoice.issue()
customer = invoice.customer
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor,
customer=customer,
canceled=False)
transaction = TransactionFactory.create(
invoice=invoice,
payment_method=payment_method,
amount=invoice.total_in_transaction_currency,
state=Transaction.States.Initial)
assert invoice.transactions.count() == 1
assert invoice.total_in_transaction_currency == -150
assert transaction.amount == -150
def test_patch_transaction_with_initial_status(self):
payment_method = PaymentMethodFactory.create(
payment_processor='someprocessor')
transaction = TransactionFactory.create(payment_method=payment_method)
url = reverse('transaction-detail',
args=[transaction.customer.pk, transaction.uuid])
valid_until = timezone.now()
currency_rate_date = timezone.now().date()
data = {
'valid_until': valid_until,
'currency': 'RON',
'currency_rate_date': currency_rate_date,
'amount': 200
}
response = self.client.patch(url, format='json', data=data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
transaction.refresh_from_db()
self.assertEqual(transaction.valid_until, valid_until)
self.assertEqual(transaction.currency, 'RON')
self.assertEqual(transaction.currency_rate_date, currency_rate_date)
self.assertEqual(transaction.amount, 200)
def test_transaction_filtering(self):
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor,
verified=True
)
transactions = TransactionFactory.create_batch(
5, payment_method=payment_method
)
filtered_transactions = [
transactions[0], transactions[2], transactions[4]
]
mock_execute = MagicMock()
with patch.multiple(TriggeredProcessor,
execute_transaction=mock_execute):
transactions_arg = [
str(transaction.pk) for transaction in filtered_transactions
]
call_command('execute_transactions',
'--transactions=%s' % ','.join(transactions_arg))
for transaction in filtered_transactions:
self.assertIn(call(transaction), mock_execute.call_args_list)
self.assertEqual(mock_execute.call_count, len(filtered_transactions))
def test_transaction_filtering(self):
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor
)
transactions = TransactionFactory.create_batch(
5, payment_method=payment_method
)
filtered_transactions = [
transactions[0], transactions[2], transactions[4]
]
mock_execute = MagicMock()
with patch.multiple(TriggeredProcessor,
execute_transaction=mock_execute):
transactions_arg = [
str(transaction.pk) for transaction in filtered_transactions
]
call_command('execute_transactions',
'--transactions=%s' % ','.join(transactions_arg))
for transaction in filtered_transactions:
self.assertIn(call(transaction), mock_execute.call_args_list)
self.assertEqual(mock_execute.call_count, len(filtered_transactions))
def test_encoding(self):
payment_method = PaymentMethodFactory.create()
factory = APIRequestFactory()
url = reverse('payment-method-detail',
kwargs={'payment_method_id': payment_method.pk,
'customer_pk': payment_method.customer.pk})
request = factory.get(url, format='json')
serializer = PaymentMethodSerializer(payment_method, context={
'request': request
})
expected_data = OrderedDict([
('url', 'http://testserver/customers/{}/payment_methods/{}/'.format(payment_method.customer.pk,
payment_method.pk)),
('transactions', None),
('customer', 'http://testserver/customers/{}/'.format(payment_method.customer.pk)),
('payment_processor', 'http://testserver/payment_processors/Manual/'),
('added_at', payment_method.added_at),
('verified_at', None),
('state', 'uninitialized')
])
json = JSONRenderer().render(serializer.data)
self.assertEqual(json, JSONRenderer().render(expected_data))
def test_filter_payment_method(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(
payment_processor='someprocessor', customer=customer)
transaction1 = TransactionFactory.create(payment_method=payment_method)
transaction_data_1 = self._transaction_data(transaction1)
transaction2 = TransactionFactory.create(payment_method=payment_method)
transaction_data_2 = self._transaction_data(transaction2)
urls = [
reverse('payment-method-transaction-list',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.pk
}),
reverse('transaction-list', kwargs={'customer_pk': customer.pk})
]
for url in urls:
url_method_someprocessor = url + '?payment_method=someprocessor'
url_no_output = url + '?payment_method=Random'
response = self.client.get(url_method_someprocessor, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data[0], transaction_data_1)
self.assertEqual(response.data[1], transaction_data_2)
response = self.client.get(url_no_output, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, [])
def test_add_transaction_with_unrelated_documents(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
invoice = InvoiceFactory.create(customer=customer)
proforma = ProformaFactory.create(customer=customer)
valid_until = datetime.now()
url = reverse('payment-method-transaction-list',
kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.pk})
invoice_url = reverse('invoice-detail', args=[invoice.pk])
proforma_url = reverse('proforma-detail', args=[proforma.pk])
data = {
'payment_method': reverse('payment-method-detail', kwargs={'customer_pk': customer.pk,
'payment_method_id': payment_method.id}),
'valid_until': valid_until,
'amount': 200.0,
'invoice': invoice_url,
'proforma': proforma_url
}
response = self.client.post(url, format='json', data=data)
expected_data = {
'non_field_errors': [u'Invoice and proforma are not related.']
}
self.assertEqual(response.data, expected_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_patch_transaction_documents(self):
payment_method = PaymentMethodFactory.create(
payment_processor='someprocessor')
transaction = TransactionFactory.create(payment_method=payment_method)
proforma = ProformaFactory.create()
invoice = InvoiceFactory.create(proforma=proforma)
proforma.invoice = invoice
proforma.save()
invoice_url = reverse('invoice-detail', args=[invoice.pk])
proforma_url = reverse('proforma-detail', args=[proforma.pk])
url = reverse('transaction-detail',
args=[transaction.customer.pk, transaction.uuid])
data = {'proforma': proforma_url, 'invoice': invoice_url}
response = self.client.patch(url, format='json', data=data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
response.data, {
'proforma': [u'This field may not be modified.'],
'invoice': [u'This field may not be modified.']
})
def test_add_transaction_with_documents_for_a_different_customer(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
proforma = ProformaFactory.create()
proforma.state = proforma.STATES.ISSUED
proforma.create_invoice()
proforma.refresh_from_db()
invoice = proforma.invoice
valid_until = datetime.now()
url = reverse('payment-method-transaction-list',
kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.pk})
invoice_url = reverse('invoice-detail', args=[invoice.pk])
proforma_url = reverse('proforma-detail', args=[proforma.pk])
data = {
'payment_method': reverse('payment-method-detail', kwargs={'customer_pk': customer.pk,
'payment_method_id': payment_method.id}),
'valid_until': valid_until,
'amount': 200.0,
'invoice': invoice_url,
'proforma': proforma_url
}
response = self.client.post(url, format='json', data=data)
expected_data = {
'non_field_errors': [u"Customer doesn't match with the one in documents."]
}
self.assertEqual(response.data, expected_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_encoding(self):
payment_method = PaymentMethodFactory.create()
factory = APIRequestFactory()
url = reverse('payment-method-detail',
kwargs={
'payment_method_id': payment_method.pk,
'customer_pk': payment_method.customer.pk
})
request = factory.get(url, format='json')
serializer = PaymentMethodSerializer(payment_method,
context={'request': request})
expected_data = OrderedDict([
('url',
'http://testserver/customers/{}/payment_methods/{}/'.format(
payment_method.customer.pk, payment_method.pk)),
('transactions', None),
('customer', 'http://testserver/customers/{}/'.format(
payment_method.customer.pk)),
('payment_processor',
'http://testserver/payment_processors/Manual/'),
('added_at', payment_method.added_at), ('verified_at', None),
('state', 'uninitialized')
])
json = JSONRenderer().render(serializer.data)
self.assertEqual(json, JSONRenderer().render(expected_data))
def test_patch_transaction_with_initial_status(self):
payment_method = PaymentMethodFactory.create(
payment_processor='someprocessor'
)
transaction = TransactionFactory.create(payment_method=payment_method)
url = reverse('transaction-detail', args=[transaction.customer.pk,
transaction.uuid])
valid_until = timezone.now()
currency_rate_date = timezone.now().date()
data = {
'valid_until': valid_until,
'currency': 'RON',
'currency_rate_date': currency_rate_date,
'amount': 200
}
response = self.client.patch(url, format='json', data=data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
transaction.refresh_from_db()
self.assertEqual(transaction.valid_until, valid_until)
self.assertEqual(transaction.currency, 'RON')
self.assertEqual(transaction.currency_rate_date, currency_rate_date)
self.assertEqual(transaction.amount, 200)
def test_documents_list_case_1(self):
"""
One proforma, one invoice, without related documents
"""
proforma = ProformaFactory.create()
invoice_entries = DocumentEntryFactory.create_batch(3)
invoice = InvoiceFactory.create(invoice_entries=invoice_entries)
invoice.issue()
payment_method = PaymentMethodFactory.create(customer=invoice.customer)
transaction = TransactionFactory.create(payment_method=payment_method,
invoice=invoice)
url = reverse('document-list')
with patch('silver.utils.payments._get_jwt_token',
new=self._jwt_token):
response = self.client.get(url)
# ^ there's a bug where specifying format='json' doesn't work
response_data = response.data
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response_data), 2)
self.assertIn(self._get_expected_data(invoice, [transaction]),
response_data)
self.assertIn(self._get_expected_data(proforma), response_data)
def test_get_transaction(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
transaction = TransactionFactory.create(payment_method=payment_method)
invoice = transaction.invoice
proforma = transaction.proforma
provider = invoice.provider
expected = OrderedDict([
('id', unicode(transaction.uuid)),
('url', reverse('transaction-detail',
kwargs={'customer_pk': customer.id, 'transaction_uuid': transaction.uuid})),
('customer', reverse('customer-detail', args=[customer.pk])),
('provider', reverse('provider-detail', args=[provider.pk])),
('amount', unicode(Decimal('0.00') + transaction.amount)),
('currency', unicode(transaction.currency)),
('currency_rate_date', None),
('state', unicode(transaction.state)),
('proforma', reverse('proforma-detail', args=[proforma.pk])),
('invoice', reverse('invoice-detail', args=[invoice.pk])),
('can_be_consumed', transaction.can_be_consumed),
('payment_method', reverse('payment-method-detail', kwargs={'customer_pk': customer.id,
'payment_method_id': payment_method.id})),
('pay_url', reverse('pay-transaction', kwargs={'transaction_uuid': transaction.uuid})),
('valid_until', None)
])
url = reverse('transaction-detail',
kwargs={'customer_pk': customer.pk,
'transaction_uuid': transaction.uuid})
response = self.client.get(url, format='json')
self.assertEqual(response.data, dict(expected))
def test_patch_transaction_documents(self):
payment_method = PaymentMethodFactory.create(
payment_processor='someprocessor'
)
transaction = TransactionFactory.create(payment_method=payment_method)
proforma = ProformaFactory.create()
invoice = InvoiceFactory.create(proforma=proforma)
proforma.invoice = invoice
proforma.save()
invoice_url = reverse('invoice-detail', args=[invoice.pk])
proforma_url = reverse('proforma-detail', args=[proforma.pk])
url = reverse('transaction-detail', args=[transaction.customer.pk,
transaction.uuid])
data = {
'proforma': proforma_url,
'invoice': invoice_url
}
response = self.client.patch(url, format='json', data=data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data, {
'proforma': [u'This field may not be modified.'],
'invoice': [u'This field may not be modified.']
})
def test_documents_list_case_1(self):
"""
One proforma, one invoice, without related documents
"""
proforma = ProformaFactory.create()
invoice = InvoiceFactory.create()
invoice.issue()
payment_method = PaymentMethodFactory.create(customer=invoice.customer)
transaction = TransactionFactory.create(payment_method=payment_method,
invoice=invoice)
url = reverse('document-list')
with patch('silver.utils.payments._get_jwt_token',
new=self._jwt_token):
response = self.client.get(url)
# ^ there's a bug where specifying format='json' doesn't work
response_data = json.loads(json.dumps(response.data))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response_data), 2)
self.assertIn(self._get_expected_data(invoice, [transaction]),
response_data)
self.assertIn(self._get_expected_data(proforma), response_data)
def test_filter_disabled(self):
customer = CustomerFactory.create()
payment = PaymentFactory.create(customer=customer, amount=100)
payment_method = PaymentMethodFactory.create(
payment_processor='someprocessor', customer=customer)
transaction = TransactionFactory.create(payment_method=payment_method,
payment=payment,
disabled=False)
transaction_data = self._transaction_data(customer, payment,
payment_method, transaction)
urls = [
reverse('payment-method-transaction-list',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.pk
}),
reverse('transaction-list', kwargs={'customer_pk': customer.pk})
]
for url in urls:
url_not_disabled = url + '?disabled=False'
url_no_output = url + '?disabled=True'
response = self.client.get(url_not_disabled, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data[0], transaction_data)
response = self.client.get(url_no_output, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, [])
def test_modify_one(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
payment = PaymentFactory.create(customer=customer)
transaction_1 = TransactionFactory.create(
payment_method=payment_method, payment=payment)
valid_until = datetime.now()
url = reverse('transaction-detail',
kwargs={
'customer_pk': customer.id,
'transaction_uuid': transaction_1.uuid
})
data = {
'payment':
reverse('payment-detail',
kwargs={
'customer_pk': customer.id,
'payment_pk': payment_method.id
}),
'valid_until':
valid_until
}
response = self.client.put(url, format='json', data=data)
self.assertEqual(response.data['detail'], 'Method "PUT" not allowed.')
response = self.client.post(url, format='json', data=data)
self.assertEqual(response.data['detail'], 'Method "POST" not allowed.')
response = self.client.patch(url, format='json', data=data)
self.assertEqual(response.data['detail'],
'Method "PATCH" not allowed.')
def test_filter_min_max_amount(self):
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor, )
customer = payment_method.customer
entry = DocumentEntryFactory(quantity=1, unit_price=100)
invoice = InvoiceFactory.create(invoice_entries=[entry],
customer=customer)
invoice.issue()
transaction = TransactionFactory.create(payment_method=payment_method,
invoice=invoice)
transaction_data = self._transaction_data(transaction)
urls = [
reverse('payment-method-transaction-list',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.pk
}),
reverse('transaction-list', kwargs={'customer_pk': customer.pk})
]
for url in urls:
url_with_filterable_data = url + '?min_amount=10'
url_no_output = url + '?min_amount=150'
with patch('silver.utils.payments._get_jwt_token') as mocked_token:
mocked_token.return_value = 'token'
response = self.client.get(url_with_filterable_data,
format='json')
transaction.refresh_from_db()
transaction_data['updated_at'] = response.data[0]['updated_at']
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data[0], transaction_data)
response = self.client.get(url_no_output, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, [])
url_with_filterable_data = url + '?max_amount=1050'
url_no_output = url + '?max_amount=10'
response = self.client.get(url_with_filterable_data,
format='json')
transaction.refresh_from_db()
transaction_data['updated_at'] = response.data[0]['updated_at']
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data[0], transaction_data)
response = self.client.get(url_no_output, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, [])
def test_add_transaction_without_currency_and_amount(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
entries = DocumentEntryFactory.create_batch(2)
proforma = ProformaFactory.create(customer=customer,
state=Proforma.STATES.ISSUED,
issue_date=timezone.now().date(),
currency='USD',
transaction_currency='RON',
transaction_xe_rate=Decimal('0.25'),
proforma_entries=entries)
proforma.create_invoice()
invoice = proforma.invoice
valid_until = datetime.now().replace(microsecond=0) + timedelta(
minutes=30)
url = reverse('payment-method-transaction-list',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.pk
})
payment_method_url = reverse('payment-method-detail',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.id
})
invoice_url = reverse('invoice-detail', args=[invoice.pk])
proforma_url = reverse('proforma-detail', args=[proforma.pk])
data = {
'payment_method':
reverse('payment-method-detail',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.id
}),
'valid_until':
valid_until,
'invoice':
invoice_url,
'proforma':
proforma_url
}
response = self.client.post(url, format='json', data=data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data['payment_method'], payment_method_url)
self.assertEqual(response.data['valid_until'][:-1],
valid_until.isoformat())
self.assertEqual(response.data['can_be_consumed'], True)
self.assertEqual(response.data['amount'],
unicode(Decimal('0.00') + invoice.transaction_total))
self.assertEqual(response.data['invoice'], invoice_url)
self.assertEqual(response.data['proforma'], proforma_url)
self.assertEqual(response.data['currency'],
invoice.transaction_currency)
def test_add_transaction(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
proforma = ProformaFactory.create(customer=customer)
proforma.state = proforma.STATES.ISSUED
proforma.create_invoice()
proforma.refresh_from_db()
invoice = proforma.invoice
payment_method_url = reverse('payment-method-detail',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.id
})
invoice_url = reverse('invoice-detail', args=[invoice.pk])
proforma_url = reverse('proforma-detail', args=[proforma.pk])
url = reverse('payment-method-transaction-list',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.pk
})
valid_until = datetime.now() + timedelta(minutes=30)
currency = 'USD'
data = {
'payment_method':
reverse('payment-method-detail',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.id
}),
'amount':
'200.0',
'invoice':
invoice_url,
'proforma':
proforma_url,
'valid_until':
valid_until,
'currency':
currency,
}
response = self.client.post(url, format='json', data=data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data['payment_method'], payment_method_url)
self.assertEqual(response.data['valid_until'][:-1],
valid_until.isoformat())
self.assertEqual(response.data['can_be_consumed'], True)
self.assertEqual(response.data['amount'], '200.00')
self.assertEqual(response.data['invoice'], invoice_url)
self.assertEqual(response.data['proforma'], proforma_url)
self.assertEqual(response.data['currency'], currency)
self.assertTrue(Transaction.objects.filter(uuid=response.data['id']))
def test_no_transaction_creation_for_issued_documents_case2(self):
"""
The payment method is not usable
"""
invoice = InvoiceFactory.create()
customer = invoice.customer
PaymentMethodFactory.create(payment_processor=triggered_processor,
customer=customer,
canceled=False)
mock_execute = MagicMock()
with patch.multiple(TriggeredProcessor,
execute_transaction=mock_execute):
invoice.issue()
transactions = Transaction.objects.filter(
invoice=invoice, proforma=invoice.related_document)
self.assertEqual(len(transactions), 0)
def test_transaction_creation_for_issued_documents(self):
"""
The happy case.
"""
invoice = InvoiceFactory.create()
customer = invoice.customer
PaymentMethodFactory.create(
payment_processor=triggered_processor, customer=customer,
canceled=False,
verified=True,
)
invoice.issue()
transactions = Transaction.objects.filter(
invoice=invoice, proforma=invoice.related_document
)
self.assertEqual(len(transactions), 1)
def test_no_transaction_creation_at_proforma_pay(self):
proforma = ProformaFactory.create(related_document=None)
customer = proforma.customer
PaymentMethodFactory.create(
payment_processor=triggered_processor, customer=customer,
canceled=False,
verified=True,
)
proforma.issue()
proforma.pay()
invoice = proforma.related_document
self.assertEqual(len(Transaction.objects.filter(proforma=proforma)), 1)
transaction = Transaction.objects.filter(proforma=proforma)[0]
self.assertEqual(transaction.invoice, invoice)
def test_transaction_creation_for_issued_documents(self):
"""
The happy case.
"""
invoice = InvoiceFactory.create()
customer = invoice.customer
PaymentMethodFactory.create(
payment_processor=triggered_processor,
customer=customer,
canceled=False,
verified=True,
)
invoice.issue()
transactions = Transaction.objects.filter(
invoice=invoice, proforma=invoice.related_document)
self.assertEqual(len(transactions), 1)
def test_no_transaction_creation_for_issued_documents_case2(self):
"""
The payment method is not usable
"""
invoice = InvoiceFactory.create()
customer = invoice.customer
PaymentMethodFactory.create(
payment_processor=triggered_processor, customer=customer,
canceled=False
)
mock_execute = MagicMock()
with patch.multiple(TriggeredProcessor, execute_transaction=mock_execute):
invoice.issue()
transactions = Transaction.objects.filter(
invoice=invoice, proforma=invoice.related_document
)
self.assertEqual(len(transactions), 0)
def test_no_transaction_creation_at_proforma_pay(self):
proforma = ProformaFactory.create(related_document=None)
customer = proforma.customer
PaymentMethodFactory.create(
payment_processor=triggered_processor, customer=customer,
canceled=False,
verified=True,
)
proforma.issue()
proforma.pay()
invoice = proforma.related_document
self.assertEqual(len(Transaction.objects.filter(proforma=proforma)), 1)
transaction = Transaction.objects.filter(proforma=proforma)[0]
self.assertEqual(transaction.invoice, invoice)
def test_create_transactions_on_verified_payment_method_creation(self):
customer = CustomerFactory.create()
lone_invoice = InvoiceFactory.create(
transaction_currency='USD',
transaction_xe_rate=Decimal('1.0'),
state=Invoice.STATES.ISSUED,
customer=customer
)
lone_proforma = ProformaFactory.create(
transaction_currency='USD',
transaction_xe_rate=Decimal('1.0'),
state=Proforma.STATES.ISSUED,
customer=customer
)
paired_proforma = ProformaFactory.create(
transaction_currency='USD',
transaction_xe_rate=Decimal('1.0'),
state=Proforma.STATES.ISSUED,
issue_date=timezone.now().date(),
customer=customer
)
paired_invoice = paired_proforma.create_invoice()
PaymentMethodFactory.create(
payment_processor=triggered_processor,
customer=customer,
canceled=False,
verified=True
)
self.assertEqual(lone_invoice.transactions.count(), 1)
self.assertEqual(lone_proforma.transactions.count(), 1)
self.assertEqual(list(paired_invoice.transactions),
list(paired_proforma.transactions))
self.assertEqual(paired_invoice.transactions.count(), 1)
def test_skip_transaction_with_unverified_payment_method(self):
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor, verified=False)
TransactionFactory.create(payment_method=payment_method)
mock_execute = MagicMock()
with patch.multiple(TriggeredProcessor,
execute_transaction=mock_execute):
call_command('execute_transactions')
self.assertEqual(mock_execute.call_count, 0)
def test_add_transaction(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
entry = DocumentEntryFactory(quantity=1, unit_price=200)
proforma = ProformaFactory.create(customer=customer,
proforma_entries=[entry])
proforma.issue()
proforma.create_invoice()
proforma.refresh_from_db()
invoice = proforma.related_document
payment_method_url = reverse('payment-method-detail',
kwargs={'customer_pk': customer.pk,
'payment_method_id': payment_method.id})
invoice_url = reverse('invoice-detail', args=[invoice.pk])
proforma_url = reverse('proforma-detail', args=[proforma.pk])
url = reverse('payment-method-transaction-list',
kwargs={'customer_pk': customer.pk,
'payment_method_id': payment_method.pk})
valid_until = datetime.now().replace(microsecond=0) + timedelta(minutes=30)
currency = invoice.transaction_currency
data = {
'payment_method': reverse('payment-method-detail',
kwargs={'customer_pk': customer.pk,
'payment_method_id': payment_method.id}),
'amount': invoice.total_in_transaction_currency,
'invoice': invoice_url,
'proforma': proforma_url,
'valid_until': valid_until,
'currency': currency,
}
response = self.client.post(url, format='json', data=data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data['payment_method'], payment_method_url)
self.assertEqual(response.data['valid_until'][:-1], valid_until.isoformat())
self.assertEqual(response.data['can_be_consumed'], True)
self.assertEqual(response.data['amount'],
force_text(invoice.total_in_transaction_currency))
self.assertEqual(response.data['invoice'], invoice_url)
self.assertEqual(response.data['proforma'], proforma_url)
self.assertEqual(response.data['currency'], currency)
self.assertTrue(Transaction.objects.filter(uuid=response.data['id']))
def test_skip_transaction_with_unverified_payment_method(self):
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor,
verified=False
)
TransactionFactory.create(payment_method=payment_method)
mock_execute = MagicMock()
with patch.multiple(TriggeredProcessor,
execute_transaction=mock_execute):
call_command('execute_transactions')
self.assertEqual(mock_execute.call_count, 0)
def test_no_transaction_creation_for_issued_documents_case3(self):
"""
There are 1 pending and 1 settled transactions that together cover the document amount.
"""
entry = DocumentEntryFactory(quantity=1, unit_price=100)
invoice = InvoiceFactory.create(invoice_entries=[entry])
invoice.issue()
customer = invoice.customer
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor,
customer=customer,
canceled=False,
verified=False,
)
TransactionFactory.create(
invoice=invoice,
payment_method=payment_method,
amount=invoice.total_in_transaction_currency / 2,
state=Transaction.States.Settled)
TransactionFactory.create(
invoice=invoice,
payment_method=payment_method,
amount=invoice.total_in_transaction_currency / 2,
state=Transaction.States.Pending)
mock_execute = MagicMock()
with patch.multiple(TriggeredProcessor,
execute_transaction=mock_execute):
expected_exception = ValidationError
expected_message = "Amount is greater than the amount that should be " \
"charged in order to pay the billing document."
try:
TransactionFactory.create(invoice=invoice,
payment_method=payment_method,
amount=1)
self.fail('{} not raised.'.format(str(expected_exception)))
except expected_exception as e:
self.assertTrue(expected_message in str(e))
transactions = Transaction.objects.filter(
payment_method=payment_method,
invoice=invoice,
)
self.assertEqual(len(transactions), 2)
self.assertEqual(mock_execute.call_count, 0)
def test_filter_payment_method(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor,
customer=customer
)
transaction1 = TransactionFactory.create(
payment_method=payment_method
)
transaction_data_1 = self._transaction_data(transaction1)
transaction2 = TransactionFactory.create(
payment_method=payment_method
)
transaction_data_2 = self._transaction_data(transaction2)
urls = [
reverse(
'payment-method-transaction-list', kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.pk}),
reverse(
'transaction-list', kwargs={'customer_pk': customer.pk})]
for url in urls:
url_method_someprocessor = (
url + '?payment_processor=' + triggered_processor
)
url_no_output = url + '?payment_processor=Random'
with patch('silver.utils.payments._get_jwt_token') as mocked_token:
mocked_token.return_value = 'token'
response = self.client.get(url_method_someprocessor, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
transaction1.refresh_from_db()
transaction_data_1['updated_at'] = response.data[1]['updated_at']
transaction1.refresh_from_db()
transaction_data_2['updated_at'] = response.data[0]['updated_at']
self.assertEqual(response.data[1], transaction_data_1)
self.assertEqual(response.data[0], transaction_data_2)
response = self.client.get(url_no_output, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, [])
def test_create_invoice_overpayment_transaction(self):
""" An invoice is issued, and it is paid in two transactions:
one for half the amount, and another for well over the
amount. """
# Create a simple invoice
entry = DocumentEntryFactory(quantity=1, unit_price=250)
invoice = InvoiceFactory.create(invoice_entries=[entry])
invoice.issue()
customer = invoice.customer
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor,
customer=customer,
canceled=False)
transaction = TransactionFactory.create(
invoice=invoice,
payment_method=payment_method,
amount=invoice.total_in_transaction_currency / 2,
state=Transaction.States.Initial)
transaction.settle()
transaction.save()
assert invoice.state != Invoice.STATES.PAID
transaction_over = TransactionFactory.create(
invoice=invoice,
payment_method=payment_method,
amount=invoice.total_in_transaction_currency * 2,
# NB:
overpayment=True,
state=Transaction.States.Initial)
transaction_over.settle()
transaction_over.save()
assert invoice.state != Invoice.STATES.PAID
invoice.pay()
assert invoice.state == Invoice.STATES.PAID
assert invoice.total_in_transaction_currency != \
invoice.amount_paid_in_transaction_currency
# Payment calculation works even with overpayment.
assert invoice.amount_paid_in_transaction_currency == \
((invoice.total_in_transaction_currency / 2) + \
(invoice.total_in_transaction_currency * 2))
def test_add_transaction_with_currency_different_from_document(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
proforma = ProformaFactory.create(customer=customer,
state=Proforma.STATES.ISSUED,
issue_date=timezone.now().date())
proforma.create_invoice()
invoice = proforma.invoice
valid_until = datetime.now().replace(microsecond=0)
url = reverse('payment-method-transaction-list',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.pk
})
invoice_url = reverse('invoice-detail', args=[invoice.pk])
proforma_url = reverse('proforma-detail', args=[proforma.pk])
data = {
'payment_method':
reverse('payment-method-detail',
kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.id
}),
'valid_until':
valid_until,
'currency':
'EUR',
'amount':
invoice.transaction_total,
'invoice':
invoice_url,
'proforma':
proforma_url
}
response = self.client.post(url, format='json', data=data)
expected_data = {
'non_field_errors': [
u"Transaction currency is different from it's "
u"document's transaction_currency."
]
}
self.assertEqual(response.data, expected_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_not_allowed_methods(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
transaction_1 = TransactionFactory.create(payment_method=payment_method)
valid_until = datetime.now()
url = reverse('transaction-detail',
kwargs={'customer_pk': customer.id,
'transaction_uuid': transaction_1.uuid})
data = {
'valid_until': valid_until
}
response = self.client.put(url, format='json', data=data)
self.assertEqual(response.data['detail'], 'Method "PUT" not allowed.')
response = self.client.post(url, format='json', data=data)
self.assertEqual(response.data['detail'], 'Method "POST" not allowed.')
def test_no_transaction_creation_for_issued_documents_case3(self):
"""
There are 1 pending and 1 settled transactions that together cover the document amount.
"""
entry = DocumentEntryFactory(quantity=1, unit_price=100)
invoice = InvoiceFactory.create(invoice_entries=[entry])
invoice.issue()
customer = invoice.customer
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor, customer=customer,
canceled=False,
verified=False,
)
TransactionFactory.create(invoice=invoice,
payment_method=payment_method,
amount=invoice.total_in_transaction_currency / 2,
state=Transaction.States.Settled)
TransactionFactory.create(invoice=invoice,
payment_method=payment_method,
amount=invoice.total_in_transaction_currency / 2,
state=Transaction.States.Pending)
mock_execute = MagicMock()
with patch.multiple(TriggeredProcessor, execute_transaction=mock_execute):
expected_exception = ValidationError
expected_message = "Amount is greater than the amount that should be " \
"charged in order to pay the billing document."
try:
TransactionFactory.create(invoice=invoice,
payment_method=payment_method,
amount=1)
self.fail('{} not raised.'.format(str(expected_exception)))
except expected_exception as e:
self.assertTrue(expected_message in str(e))
transactions = Transaction.objects.filter(
payment_method=payment_method, invoice=invoice,
)
self.assertEqual(len(transactions), 2)
self.assertEqual(mock_execute.call_count, 0)
def test_create_one_without_required_fields(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
transaction = TransactionFactory.create(payment_method=payment_method)
valid_until = datetime.now()
data = {
'valid_until': valid_until
}
url = reverse('payment-method-transaction-list',
kwargs={'customer_pk': customer.id,
'payment_method_id': payment_method.id})
response = self.client.post(url, format='json', data=data)
self.assertEqual(response.data['payment_method'],
['This field is required.'])
def test_transaction_executing(self):
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor,
verified=True
)
transactions = TransactionFactory.create_batch(
5, payment_method=payment_method
)
mock_execute = MagicMock()
with patch.multiple(TriggeredProcessor,
execute_transaction=mock_execute):
call_command('execute_transactions')
for transaction in transactions:
self.assertIn(call(transaction), mock_execute.call_args_list)
self.assertEqual(mock_execute.call_count, len(transactions))
def test_filter_min_max_amount(self):
customer = CustomerFactory.create()
payment_method_ok = PaymentMethodFactory.create(
payment_processor='someprocessor',
customer=customer)
transaction = TransactionFactory.create(
payment_method=payment_method_ok,
amount=100
)
transaction_data = self._transaction_data(transaction)
urls = [
reverse(
'payment-method-transaction-list', kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method_ok.pk}),
reverse(
'transaction-list', kwargs={'customer_pk': customer.pk})]
for url in urls:
url_with_filterable_data = url + '?min_amount=10'
url_no_output = url + '?min_amount=150'
response = self.client.get(url_with_filterable_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data[0], transaction_data)
response = self.client.get(url_no_output, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, [])
url_with_filterable_data = url + '?max_amount=1050'
url_no_output = url + '?max_amount=10'
response = self.client.get(url_with_filterable_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data[0], transaction_data)
response = self.client.get(url_no_output, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, [])
def test_encoding(self):
now = timezone.now().replace(microsecond=0)
payment_method = PaymentMethodFactory.create(added_at=now)
factory = APIRequestFactory()
url = reverse('payment-method-detail',
kwargs={'payment_method_id': payment_method.pk,
'customer_pk': payment_method.customer.pk})
request = factory.get(url, format='json')
serializer = PaymentMethodSerializer(payment_method, context={
'request': request
})
self_url = build_absolute_test_url(url)
transactions_url = build_absolute_test_url(
reverse('payment-method-transaction-list',
[payment_method.pk, payment_method.customer.pk])
)
customer_url = build_absolute_test_url(
reverse('customer-detail', [payment_method.customer.pk])
)
expected_data = OrderedDict([
('url', self_url),
('transactions', transactions_url),
('customer', customer_url),
('payment_processor_name', manual_processor),
('payment_processor', OrderedDict([
("type", ManualProcessor.type),
("name", manual_processor),
("allowed_currencies", []),
("url", build_absolute_test_url(reverse('payment-processor-detail', ['manual'])))
])),
('added_at', payment_method.added_at),
('verified', False),
('canceled', False),
('valid_until', None),
('display_info', None),
])
json = JSONRenderer().render(serializer.data)
self.assertEqual(json, JSONRenderer().render(expected_data))
def test_exception_logging(self, mock_logger):
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor,
verified=True
)
TransactionFactory.create(payment_method=payment_method)
mock_execute = MagicMock()
mock_execute.side_effect = Exception('This happened.')
with patch.multiple(TriggeredProcessor,
execute_transaction=mock_execute):
call_command('execute_transactions')
expected_call = call(
'Encountered exception while executing transaction with id=%s.',
1, exc_info=True
)
self.assertEqual(expected_call, mock_logger.call_args)
def test_transaction_update_status_exception_logging(self, mock_logger):
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor
)
TransactionFactory.create(payment_method=payment_method,
state=Transaction.States.Pending)
mock_fetch_status = MagicMock()
mock_fetch_status.side_effect = Exception('This happened.')
with patch.multiple(TriggeredProcessor,
fetch_transaction_status=mock_fetch_status):
call_command('fetch_transactions_status')
expected_call = call(
'Encountered exception while updating transaction with id=%s.',
1, exc_info=True
)
self.assertEqual(expected_call, mock_logger.call_args)
def test_fetch_transaction_status_call(self):
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor
)
transactions = TransactionFactory.create_batch(
5, payment_method=payment_method, state=Transaction.States.Pending
)
mock_fetch_status = MagicMock()
with patch.multiple(TriggeredProcessor,
fetch_transaction_status=mock_fetch_status):
call_command('fetch_transactions_status')
for transaction in transactions:
self.assertIn(call(transaction),
mock_fetch_status.call_args_list)
self.assertEqual(mock_fetch_status.call_count,
len(transactions))
def test_add_transaction(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
proforma = ProformaFactory.create(customer=customer)
proforma.state = proforma.STATES.ISSUED
proforma.create_invoice()
proforma.refresh_from_db()
invoice = proforma.invoice
payment_method_url = reverse('payment-method-detail', kwargs={'customer_pk': customer.pk,
'payment_method_id': payment_method.id})
invoice_url = reverse('invoice-detail', args=[invoice.pk])
proforma_url = reverse('proforma-detail', args=[proforma.pk])
url = reverse('payment-method-transaction-list',
kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.pk})
valid_until = datetime.now() + timedelta(minutes=30)
currency = 'USD'
data = {
'payment_method': reverse('payment-method-detail', kwargs={'customer_pk': customer.pk,
'payment_method_id': payment_method.id}),
'amount': '200.0',
'invoice': invoice_url,
'proforma': proforma_url,
'valid_until': valid_until,
'currency': currency,
}
response = self.client.post(url, format='json', data=data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data['payment_method'], payment_method_url)
self.assertEqual(response.data['valid_until'][:-1], valid_until.isoformat())
self.assertEqual(response.data['can_be_consumed'], True)
self.assertEqual(response.data['amount'], '200.00')
self.assertEqual(response.data['invoice'], invoice_url)
self.assertEqual(response.data['proforma'], proforma_url)
self.assertEqual(response.data['currency'], currency)
self.assertTrue(Transaction.objects.filter(uuid=response.data['id']))
def test_create_transaction_with_not_allowed_currency(self):
invoice = InvoiceFactory.create(transaction_currency='EUR',
transaction_xe_rate=Decimal('1.0'),
state=Invoice.STATES.ISSUED)
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor,
customer=invoice.customer,
canceled=False,
verified=False
)
expected_exception = ValidationError
expected_message = 'Currency EUR is not allowed by ' \
'the payment method. Allowed currencies are ' \
'[\'RON\', \'USD\'].'
try:
TransactionFactory.create(payment_method=payment_method,
invoice=invoice)
self.fail('{} not raised.'.format(str(expected_exception)))
except expected_exception as e:
self.assertTrue(expected_message in str(e))
def test_add_transaction_without_documents(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
valid_until = datetime.now()
url = reverse('payment-method-transaction-list',
kwargs={'customer_pk': customer.pk, 'payment_method_id': payment_method.pk})
data = {
'payment_method': reverse('payment-method-detail', kwargs={'customer_pk': customer.pk,
'payment_method_id': payment_method.id}),
'valid_until': valid_until,
'amount': 200.0,
}
response = self.client.post(url, format='json', data=data)
expected_data = {
'non_field_errors': [u'The transaction must have at '
u'least one document (invoice or proforma).']
}
self.assertEqual(response.data, expected_data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_filter_payment_method(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(
payment_processor='someprocessor',
customer=customer)
transaction1 = TransactionFactory.create(
payment_method=payment_method
)
transaction_data_1 = self._transaction_data(transaction1)
transaction2 = TransactionFactory.create(
payment_method=payment_method
)
transaction_data_2 = self._transaction_data(transaction2)
urls = [
reverse(
'payment-method-transaction-list', kwargs={
'customer_pk': customer.pk,
'payment_method_id': payment_method.pk}),
reverse(
'transaction-list', kwargs={'customer_pk': customer.pk})]
for url in urls:
url_method_someprocessor = url + '?payment_method=someprocessor'
url_no_output = url + '?payment_method=Random'
response = self.client.get(url_method_someprocessor, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data[0], transaction_data_1)
self.assertEqual(response.data[1], transaction_data_2)
response = self.client.get(url_no_output, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, [])
