def test_get_proforma(self):
ProformaFactory.reset_sequence(1)
proforma = ProformaFactory.create()
url = reverse('proforma-detail', kwargs={'pk': proforma.pk})
response = self.client.get(url)
assert response.status_code == status.HTTP_200_OK
assert response.data == {
"id": proforma.pk,
"series": "ProformaSeries",
"number": 1,
"provider": "http://testserver/providers/%s/" % proforma.provider.pk,
"customer": "http://testserver/customers/%s/" % proforma.customer.pk,
"archived_provider": {},
"archived_customer": {},
"due_date": None,
"issue_date": None,
"paid_date": None,
"cancel_date": None,
"sales_tax_name": "VAT",
"sales_tax_percent": '1.00',
"currency": "RON",
'pdf_url': None,
"state": "draft",
"invoice": None,
"proforma_entries": [],
'total': Decimal('0.00'),
}
def test_issue_proforma_with_custom_issue_date_and_due_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
ProformaFactory.create(provider=provider, customer=customer)
url = reverse('proforma-state', kwargs={'pk': 1})
data = {
'state': 'issued',
'issue_date': '2014-01-01',
'due_date': '2014-01-20'
}
response = self.client.put(url, data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
mandatory_content = {
'issue_date': '2014-01-01',
'due_date': '2014-01-20',
'state': 'issued'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
assert response.data.get('archived_provider', {}) != {}
assert response.data.get('archived_customer', {}) != {}
assert Invoice.objects.count() == 0
proforma = get_object_or_None(Proforma, pk=1)
def test_get_proforma(self):
ProformaFactory.reset_sequence(1)
ProformaFactory.create()
url = reverse('proforma-detail', kwargs={'pk': 1})
response = self.client.get(url)
assert response.status_code == status.HTTP_200_OK
assert response.data == {
"id": 1,
"series": "ProformaSeries",
"number": 1,
"provider": "http://testserver/providers/1/",
"customer": "http://testserver/customers/1/",
"archived_provider": {},
"archived_customer": {},
"due_date": None,
"issue_date": None,
"paid_date": None,
"cancel_date": None,
"sales_tax_name": "VAT",
"sales_tax_percent": '1.00',
"currency": "RON",
'pdf_url': None,
"state": "draft",
"invoice": None,
"proforma_entries": [],
'total': Decimal('0.00'),
}
def test_get_proforma(self):
ProformaFactory.reset_sequence(1)
proforma = ProformaFactory.create()
url = reverse('proforma-detail', kwargs={'pk': proforma.pk})
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, {
"id": proforma.pk,
"series": "ProformaSeries",
"number": 1,
"provider": "http://testserver/providers/%s/" % proforma.provider.pk,
"customer": "http://testserver/customers/%s/" % proforma.customer.pk,
"archived_provider": {},
"archived_customer": {},
"due_date": None,
"issue_date": None,
"paid_date": None,
"cancel_date": None,
"sales_tax_name": "VAT",
"sales_tax_percent": '1.00',
"currency": "RON",
"transaction_currency": proforma.transaction_currency,
"transaction_xe_rate": ("%.4f" % proforma.transaction_xe_rate
if proforma.transaction_xe_rate else None),
"transaction_xe_date": proforma.transaction_xe_date,
"pdf_url": None,
"state": "draft",
"invoice": None,
"proforma_entries": [],
"total": Decimal('0.00'),
"total_in_transaction_currency": Decimal('0.00'),
"transactions": []
})
def test_delete_proforma_entry(self):
ProformaFactory.create()
url = reverse('proforma-entry-create', kwargs={'document_pk': 1})
entry_data = {
"description": "Page views",
"unit_price": 10.0,
"quantity": 20
}
entries_count = 10
for cnt in range(entries_count):
self.client.post(url,
data=json.dumps(entry_data),
content_type='application/json')
url = reverse('proforma-entry-update',
kwargs={
'document_pk': 1,
'entry_pk': 1
})
response = self.client.delete(url)
assert response.status_code == status.HTTP_204_NO_CONTENT
url = reverse('proforma-detail', kwargs={'pk': 1})
response = self.client.get(url)
invoice_entries = response.data.get('proforma_entries', None)
assert len(invoice_entries) == entries_count - 1
def test_issue_proforma_with_custom_issue_date_and_due_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
ProformaFactory.create(provider=provider, customer=customer)
url = reverse('proforma-state', kwargs={'pk': 1})
data = {
'state': 'issued',
'issue_date': '2014-01-01',
'due_date': '2014-01-20'
}
response = self.client.put(url,
data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
mandatory_content = {
'issue_date': '2014-01-01',
'due_date': '2014-01-20',
'state': 'issued'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
assert response.data.get('archived_provider', {}) != {}
assert response.data.get('archived_customer', {}) != {}
assert Invoice.objects.count() == 0
proforma = get_object_or_None(Proforma, pk=1)
def test_actions_failed_no_log_entries(self):
ProformaFactory.create()
url = reverse('admin:silver_proforma_changelist')
mock_log_entry = MagicMock()
mock_log_action = MagicMock()
mock_log_entry.objects.log_action = mock_log_action
exceptions = cycle([ValueError, TransitionNotAllowed])
def _exception_thrower(*args):
raise exceptions.next()
mock_action = MagicMock(side_effect=_exception_thrower)
mock_proforma = MagicMock()
mock_proforma.issue = mock_action
mock_proforma.cancel = mock_action
mock_proforma.pay = mock_action
mock_proforma.clone_into_draft = mock_action
mock_proforma.create_invoice = mock_action
with patch.multiple('silver.admin',
LogEntry=mock_log_entry,
Proforma=mock_proforma):
actions = ['issue', 'pay', 'cancel', 'clone', 'create_invoice']
for action in actions:
self.admin.post(url, {
'action': action,
'_selected_action': [u'1']
})
assert not mock_log_action.call_count
def test_pay_proforma_when_in_draft_state(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
ProformaFactory.create(provider=provider, customer=customer)
url = reverse('proforma-state', kwargs={'pk': 1})
data = {'state': 'paid'}
response = self.client.put(url, data=json.dumps(data), content_type='application/json')
assert response.status_code == status.HTTP_403_FORBIDDEN
assert response.data == {'detail': 'A proforma can be paid only if it is in issued state.'}
assert Invoice.objects.count() == 0
def test_pay_proforma_when_in_draft_state(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
ProformaFactory.create(provider=provider, customer=customer)
url = reverse('proforma-state', kwargs={'pk': 1})
data = {'state': 'paid'}
response = self.client.put(url, data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_403_FORBIDDEN
assert response.data == {'detail': 'A proforma can be paid only if it is in issued state.'}
assert Invoice.objects.count() == 0
def test_get_proformas(self):
batch_size = 50
ProformaFactory.create_batch(batch_size)
url = reverse('proforma-list')
response = self.client.get(url)
assert response.status_code == status.HTTP_200_OK
response = self.client.get(url + '?page=2')
assert response.status_code == status.HTTP_200_OK
def test_get_proformas(self):
batch_size = 50
ProformaFactory.create_batch(batch_size)
url = reverse('proforma-list')
response = self.client.get(url)
assert response.status_code == status.HTTP_200_OK
response = self.client.get(url + '?page=2')
assert response.status_code == status.HTTP_200_OK
def test_illegal_state_change_when_in_draft_state(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
ProformaFactory.create(provider=provider, customer=customer)
url = reverse('proforma-state', kwargs={'pk': 1})
data = {'state': 'illegal-state'}
response = self.client.put(url, data=json.dumps(data), content_type='application/json')
assert response.status_code == status.HTTP_403_FORBIDDEN
assert response.data == {'detail': 'Illegal state value.'}
assert Invoice.objects.count() == 0
def test_illegal_state_change_when_in_draft_state(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
ProformaFactory.create(provider=provider, customer=customer)
url = reverse('proforma-state', kwargs={'pk': 1})
data = {'state': 'illegal-state'}
response = self.client.put(url, data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_403_FORBIDDEN
assert response.data == {'detail': 'Illegal state value.'}
assert Invoice.objects.count() == 0
def test_get_proforma(self, mocked_settings):
ProformaFactory.reset_sequence(1)
upload_path = '%s/documents/' % settings.MEDIA_ROOT
proforma = ProformaFactory.create(pdf=PDF.objects.create(upload_path=upload_path))
proforma.generate_pdf()
url = reverse('proforma-detail', kwargs={'pk': proforma.pk})
for show_pdf_storage_url, pdf_url in [
(True, build_absolute_test_url(proforma.pdf.url)),
(False, build_absolute_test_url(reverse('pdf', args=[proforma.pdf.pk])))
]:
mocked_settings.SILVER_SHOW_PDF_STORAGE_URL = show_pdf_storage_url
response = self.client.get(url)
provider_url = build_absolute_test_url(reverse('provider-detail',
[proforma.provider.pk]))
customer_url = build_absolute_test_url(reverse('customer-detail',
[proforma.customer.pk]))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, {
"id": proforma.pk,
"series": "ProformaSeries",
"number": proforma.number,
"provider": provider_url,
"customer": customer_url,
"archived_provider": '{}',
"archived_customer": '{}',
"due_date": None,
"issue_date": None,
"paid_date": None,
"cancel_date": None,
"sales_tax_name": "VAT",
"sales_tax_percent": '1.00',
"currency": "RON",
"transaction_currency": proforma.transaction_currency,
"transaction_xe_rate": ("%.4f" % proforma.transaction_xe_rate
if proforma.transaction_xe_rate else None),
"transaction_xe_date": proforma.transaction_xe_date,
"pdf_url": pdf_url,
"state": "draft",
"invoice": None,
"proforma_entries": [],
"total": 0,
"total_in_transaction_currency": 0,
"transactions": []
})
def test_add_single_proforma_entry(self):
ProformaFactory.create_batch(10)
url = reverse('proforma-entry-create', kwargs={'document_pk': 1})
entry_data = {
"description": "Page views",
"unit_price": 10.0,
"quantity": 20
}
response = self.client.post(url,
data=json.dumps(entry_data),
content_type='application/json')
proforma = Proforma.objects.get(pk=1)
total = Decimal(200.0) * Decimal(1 + proforma.sales_tax_percent / 100)
assert response.status_code == status.HTTP_201_CREATED
assert response.data == {
'description': 'Page views',
'unit': None,
'quantity': '20.0000',
'unit_price': '10.0000',
'start_date': None,
'end_date': None,
'prorated': False,
'product_code': None,
'total': total,
'total_before_tax': Decimal(200.0)
}
url = reverse('proforma-detail', kwargs={'pk': 1})
response = self.client.get(url)
invoice_entries = response.data.get('proforma_entries', None)
assert len(invoice_entries) == 1
assert invoice_entries[0] == {
'description': 'Page views',
'unit': None,
'quantity': '20.0000',
'unit_price': '10.0000',
'start_date': None,
'end_date': None,
'prorated': False,
'product_code': None,
'total': total,
'total_before_tax': Decimal(200.0)
}
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 handle(self, *args, **options):
proforma = ProformaFactory.create(proforma_entries=[DocumentEntryFactory.create()],
state=Proforma.STATES.ISSUED)
proforma.create_invoice()
invoice = InvoiceFactory.create(invoice_entries=[DocumentEntryFactory.create()],
state=Invoice.STATES.ISSUED,
related_document=None)
TransactionFactory.create(state=Transaction.States.Settled,
invoice=invoice,
payment_method__customer=invoice.customer,
proforma=None)
InvoiceFactory.create_batch(size=3,
invoice_entries=[DocumentEntryFactory.create()],
state=Invoice.STATES.PAID,
related_document=None)
InvoiceFactory.create_batch(size=3,
invoice_entries=[DocumentEntryFactory.create()],
state=Invoice.STATES.DRAFT,
related_document=None)
InvoiceFactory.create_batch(size=3,
invoice_entries=[DocumentEntryFactory.create()],
state=Invoice.STATES.CANCELED,
related_document=None)
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_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_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_proforma_total_before_tax_decimal_places(self):
proforma_entries = DocumentEntryFactory.create_batch(3)
proforma = ProformaFactory.create(proforma_entries=proforma_entries)
proforma.sales_tax_percent = Decimal('20.00')
assert self._get_decimal_places(proforma.total_before_tax) == 2
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_proforma_currency_used_for_transaction_currency(self):
customer = CustomerFactory.create(currency=None)
proforma = ProformaFactory.create(customer=customer,
currency='EUR',
transaction_currency=None)
self.assertEqual(proforma.transaction_currency, 'EUR')
def test_proforma_total_with_tax_integrity(self):
proforma_entries = DocumentEntryFactory.create_batch(5)
proforma = ProformaFactory.create(proforma_entries=proforma_entries)
proforma.sales_tax_percent = Decimal('20.00')
assert proforma.total == proforma.total_before_tax + proforma.tax_value
def test_pay_proforma_with_provided_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
proforma.issue()
url = reverse('proforma-state', kwargs={'pk': proforma.pk})
data = {
'state': 'paid',
'paid_date': '2014-05-05'
}
response = self.client.put(url, data=json.dumps(data), content_type='application/json')
proforma.refresh_from_db()
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
invoice_url = build_absolute_test_url(reverse('invoice-detail',
[proforma.related_document.pk]))
mandatory_content = {
'issue_date': timezone.now().date().strftime('%Y-%m-%d'),
'due_date': due_date.strftime('%Y-%m-%d'),
'paid_date': '2014-05-05',
'state': 'paid',
'invoice': invoice_url
}
assert response.status_code == status.HTTP_200_OK
assert all(item in list(response.data.items())
for item in mandatory_content.items())
invoice = Invoice.objects.all()[0]
assert proforma.related_document == invoice
assert invoice.related_document == proforma
def handle(self, *args, **options):
proforma = ProformaFactory.create(proforma_entries=[DocumentEntryFactory.create()],
state=Proforma.STATES.ISSUED)
proforma.create_invoice()
invoice = InvoiceFactory.create(invoice_entries=[DocumentEntryFactory.create()],
state=Invoice.STATES.ISSUED,
related_document=None)
TransactionFactory.create(state=Transaction.States.Settled,
invoice=invoice,
payment_method__customer=invoice.customer,
proforma=None)
InvoiceFactory.create_batch(size=3,
invoice_entries=[DocumentEntryFactory.create()],
state=Invoice.STATES.PAID,
related_document=None)
InvoiceFactory.create_batch(size=3,
invoice_entries=[DocumentEntryFactory.create()],
state=Invoice.STATES.DRAFT,
related_document=None)
InvoiceFactory.create_batch(size=3,
invoice_entries=[DocumentEntryFactory.create()],
state=Invoice.STATES.CANCELED,
related_document=None)
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_add_proforma_entry_in_paid_state(self):
proforma = ProformaFactory.create()
proforma.issue()
proforma.pay()
proforma.save()
url = reverse('proforma-entry-create',
kwargs={'document_pk': proforma.pk})
entry_data = {
"description": "Page views",
"unit_price": 10.0,
"quantity": 20
}
response = self.client.post(url,
data=json.dumps(entry_data),
content_type='application/json')
assert response.status_code == status.HTTP_403_FORBIDDEN
msg = 'Proforma entries can be added only when the proforma is in draft state.'
assert response.data == {'detail': msg}
url = reverse('proforma-detail', kwargs={'pk': proforma.pk})
response = self.client.get(url)
invoice_entries = response.data.get('proforma_entries', None)
assert len(invoice_entries) == 0
def test_pay_proforma_with_provided_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
proforma.issue()
proforma.save()
url = reverse('proforma-state', kwargs={'pk': proforma.pk})
data = {
'state': 'paid',
'paid_date': '2014-05-05'
}
response = self.client.put(url, data=json.dumps(data), content_type='application/json')
proforma.refresh_from_db()
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date': timezone.now().date().strftime('%Y-%m-%d'),
'due_date': due_date.strftime('%Y-%m-%d'),
'paid_date': '2014-05-05',
'state': 'paid',
'invoice': 'http://testserver/invoices/%s/' % proforma.invoice.pk
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
invoice = Invoice.objects.all()[0]
assert proforma.invoice == invoice
assert invoice.proforma == proforma
invoice = get_object_or_None(Invoice, proforma=proforma)
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_pay_proforma_with_provided_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
proforma.issue()
proforma.save()
url = reverse('proforma-state', kwargs={'pk': proforma.pk})
data = {
'state': 'paid',
'paid_date': '2014-05-05'
}
response = self.client.put(url, data=json.dumps(data), content_type='application/json')
proforma.refresh_from_db()
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date': timezone.now().date().strftime('%Y-%m-%d'),
'due_date': due_date.strftime('%Y-%m-%d'),
'paid_date': '2014-05-05',
'state': 'paid',
'invoice': 'http://testserver/invoices/%s/' % proforma.invoice.pk
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
invoice = Invoice.objects.all()[0]
assert proforma.invoice == invoice
assert invoice.proforma == proforma
invoice = get_object_or_None(Invoice, proforma=proforma)
def test_proforma_tax_value_decimal_places(self):
proforma_entries = DocumentEntryFactory.create_batch(3)
proforma = ProformaFactory.create(proforma_entries=proforma_entries)
proforma.sales_tax_percent = Decimal('20.00')
assert self._get_decimal_places(proforma.tax_value) == 2
def test_issue_proforma_with_default_dates(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
url = reverse('proforma-state', kwargs={'pk': 1})
data = {'state': 'issued'}
response = self.client.put(url, data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date': timezone.now().date().strftime('%Y-%m-%d'),
'due_date': due_date.strftime('%Y-%m-%d'),
'state': 'issued'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
assert response.data.get('archived_provider', {}) != {}
assert response.data.get('archived_customer', {}) != {}
assert Invoice.objects.count() == 0
proforma = get_object_or_None(Proforma, pk=1)
def test_add_transaction_with_draft_document(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(customer=customer)
proforma = ProformaFactory.create(customer=customer)
proforma_url = reverse('proforma-detail', args=[proforma.pk])
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.pk}),
'valid_until': valid_until,
'amount': 200.0,
'proforma': proforma_url
}
response = self.client.post(url, format='json', data=data)
expected_data = {
'non_field_errors': [u'The transaction must have a non-draft billing document '
u'(invoice or proforma).']
}
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_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_cancel_proforma_with_provided_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
proforma.issue()
proforma.save()
url = reverse('proforma-state', kwargs={'pk': proforma.pk})
data = {
'state': 'canceled',
'cancel_date': '2014-10-10'
}
response = self.client.put(url, data=json.dumps(data), content_type='application/json')
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date': timezone.now().date().strftime('%Y-%m-%d'),
'due_date': due_date.strftime('%Y-%m-%d'),
'cancel_date': '2014-10-10',
'state': 'canceled'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
assert Invoice.objects.count() == 0
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_proforma_total_with_tax_integrity(self):
proforma_entries = DocumentEntryFactory.create_batch(5)
proforma = ProformaFactory.create(proforma_entries=proforma_entries)
proforma.sales_tax_percent = Decimal('20.00')
assert proforma.total == proforma.total_before_tax + proforma.tax_value
def test_proforma_currency_used_for_transaction_currency(self):
customer = CustomerFactory.create(currency=None)
proforma = ProformaFactory.create(customer=customer,
currency='EUR',
transaction_currency=None)
self.assertEqual(proforma.transaction_currency, 'EUR')
def test_pay_proforma_with_provided_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
proforma.issue()
url = reverse('proforma-state', kwargs={'pk': proforma.pk})
data = {'state': 'paid', 'paid_date': '2014-05-05'}
response = self.client.put(url,
data=json.dumps(data),
content_type='application/json')
proforma.refresh_from_db()
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
invoice_url = build_absolute_test_url(
reverse('invoice-detail', [proforma.related_document.pk]))
mandatory_content = {
'issue_date': timezone.now().date().strftime('%Y-%m-%d'),
'due_date': due_date.strftime('%Y-%m-%d'),
'paid_date': '2014-05-05',
'state': 'paid',
'invoice': invoice_url
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
invoice = Invoice.objects.all()[0]
assert proforma.related_document == invoice
assert invoice.related_document == proforma
def test_issue_proforma_with_custom_issue_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
url = reverse('proforma-state', kwargs={'pk': proforma.pk})
data = {'state': 'issued', 'issue_date': '2014-01-01'}
response = self.client.put(url,
data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date': '2014-01-01',
'due_date': due_date.strftime('%Y-%m-%d'),
'state': 'issued'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
assert response.data.get('archived_provider', {}) != {}
assert response.data.get('archived_customer', {}) != {}
assert Invoice.objects.count() == 0
proforma = get_object_or_None(Proforma, pk=1)
def test_cancel_proforma_with_provided_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
proforma.issue()
proforma.save()
url = reverse('proforma-state', kwargs={'pk': proforma.pk})
data = {
'state': 'canceled',
'cancel_date': '2014-10-10'
}
response = self.client.put(url, data=json.dumps(data), content_type='application/json')
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date': timezone.now().date().strftime('%Y-%m-%d'),
'due_date': due_date.strftime('%Y-%m-%d'),
'cancel_date': '2014-10-10',
'state': 'canceled'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
assert Invoice.objects.count() == 0
def test_add_single_proforma_entry(self):
ProformaFactory.create_batch(10)
url = reverse('proforma-entry-create', kwargs={'document_pk': 1})
entry_data = {
"description": "Page views",
"unit_price": 10.0,
"quantity": 20
}
response = self.client.post(url, data=json.dumps(entry_data),
content_type='application/json')
proforma = Proforma.objects.get(pk=1)
total = Decimal(200.0) * Decimal(1 + proforma.sales_tax_percent / 100)
assert response.status_code == status.HTTP_201_CREATED
assert response.data == {
'description': 'Page views',
'unit': None,
'quantity': '20.0000',
'unit_price': '10.0000',
'start_date': None,
'end_date': None,
'prorated': False,
'product_code': None,
'total': total,
'total_before_tax': Decimal(200.0)
}
url = reverse('proforma-detail', kwargs={'pk': 1})
response = self.client.get(url)
invoice_entries = response.data.get('proforma_entries', None)
assert len(invoice_entries) == 1
assert invoice_entries[0] == {
'description': 'Page views',
'unit': None,
'quantity': '20.0000',
'unit_price': '10.0000',
'start_date': None,
'end_date': None,
'prorated': False,
'product_code': None,
'total': total,
'total_before_tax': Decimal(200.0)
}
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_create_transactions_on_payment_method_verify(self):
customer = CustomerFactory.create()
payment_method = PaymentMethodFactory.create(
payment_processor=triggered_processor,
customer=customer,
canceled=False,
verified=False
)
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()
self.assertEqual(payment_method.transactions.count(), 0)
payment_method.verified = True
payment_method.save()
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_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_pay_proforma_related_invoice_state_change_to_paid(self):
proforma = ProformaFactory.create()
proforma.issue()
proforma.create_invoice()
proforma.pay()
assert proforma.related_document.state == Invoice.STATES.PAID
assert proforma.state == Invoice.STATES.PAID
def test_pay_proforma_related_invoice_state_change_to_paid(self):
proforma = ProformaFactory.create()
proforma.issue()
proforma.create_invoice()
proforma.pay()
assert proforma.related_document.state == Invoice.STATES.PAID
assert proforma.state == Invoice.STATES.PAID
def test_cancel_issued_proforma_with_related_invoice(self):
proforma = ProformaFactory.create()
proforma.issue()
if not proforma.related_document:
proforma.create_invoice()
proforma.cancel()
assert proforma.state == proforma.related_document.state == Proforma.STATES.CANCELED
def test_draft_proforma_series_number(self):
proforma = ProformaFactory.create()
proforma.number = None
assert proforma.series_number == '%s-draft-id:%d' % (proforma.series,
proforma.pk)
proforma.series = None
assert proforma.series_number == 'draft-id:%d' % proforma.pk
def test_draft_proforma_series_number(self):
proforma = ProformaFactory.create()
proforma.number = None
assert proforma.series_number == '%s-draft-id:%d' % (proforma.series,
proforma.pk)
proforma.series = None
assert proforma.series_number == 'draft-id:%d' % proforma.pk
def test_cancel_issued_proforma_with_related_invoice(self):
proforma = ProformaFactory.create()
proforma.issue()
if not proforma.related_document:
proforma.create_invoice()
proforma.cancel()
assert proforma.state == proforma.related_document.state == Proforma.STATES.CANCELED
def test_cancel_issued_invoice_with_related_proforma(self):
proforma = ProformaFactory.create()
proforma.issue()
if not proforma.invoice:
proforma.create_invoice()
proforma.invoice.cancel()
proforma.invoice.save()
assert proforma.invoice.state == proforma.state == Invoice.STATES.CANCELED
def test_edit_proforma_in_issued_state(self):
proforma = ProformaFactory.create()
proforma.issue()
proforma.save()
url = reverse('proforma-detail', kwargs={'pk': proforma.pk})
data = {"description": "New Page views"}
response = self.client.patch(url, data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert response.data == {'non_field_errors': ['You cannot edit the document once it is in issued state.']}
def test_pay_invoice_related_proforma_state_change_to_paid(self):
proforma = ProformaFactory.create()
proforma.issue()
proforma.create_invoice()
assert proforma.invoice.state == Invoice.STATES.ISSUED
proforma.invoice.pay()
proforma.invoice.save()
assert proforma.invoice.state == Invoice.STATES.PAID
assert proforma.state == Proforma.STATES.PAID
def test_generate_pdfs_task(monkeypatch):
issued_invoice = InvoiceFactory.create()
issued_invoice.issue()
paid_invoice = InvoiceFactory.create()
paid_invoice.issue()
paid_invoice.pay()
canceled_invoice = InvoiceFactory.create()
canceled_invoice.issue()
canceled_invoice.cancel()
issued_invoice_already_generated = InvoiceFactory.create()
issued_invoice_already_generated.issue()
issued_invoice_already_generated.pdf.dirty = False
issued_invoice_already_generated.pdf.save()
issued_proforma = ProformaFactory.create()
issued_proforma.issue()
issued_proforma_already_generated = ProformaFactory.create()
issued_proforma_already_generated.issue()
issued_proforma_already_generated.pdf.dirty = False
issued_proforma_already_generated.pdf.save()
documents_to_generate = [issued_invoice, canceled_invoice, paid_invoice,
issued_proforma]
for document in documents_to_generate:
assert document.pdf.dirty
lock_mock = MagicMock()
monkeypatch.setattr('silver.tasks.redis.lock', lock_mock)
with patch('silver.tasks.group') as group_mock:
generate_pdfs()
assert group_mock.call_count
def test_delete_proforma_entry(self):
ProformaFactory.create()
url = reverse('proforma-entry-create', kwargs={'document_pk': 1})
entry_data = {
"description": "Page views",
"unit_price": 10.0,
"quantity": 20
}
entries_count = 10
for cnt in range(entries_count):
self.client.post(url, data=json.dumps(entry_data),
content_type='application/json')
url = reverse('proforma-entry-update', kwargs={'document_pk': 1,
'entry_pk': 1})
response = self.client.delete(url)
assert response.status_code == status.HTTP_204_NO_CONTENT
url = reverse('proforma-detail', kwargs={'pk': 1})
response = self.client.get(url)
invoice_entries = response.data.get('proforma_entries', None)
assert len(invoice_entries) == entries_count - 1
