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_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_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_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 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_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_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_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_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_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