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() 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_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) 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_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_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_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_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 least one billing document ' u'(invoice or proforma).' ] } 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_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_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.related_document 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'], force_str(invoice.total_in_transaction_currency)) self.assertEqual(response.data['invoice'], invoice_url) self.assertEqual(response.data['proforma'], proforma_url) self.assertEqual(response.data['currency'], invoice.transaction_currency)
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_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_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_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_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.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, 'currency': 'EUR', 'amount': invoice.total_in_transaction_currency, '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_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_get_transaction(self): customer = CustomerFactory.create() payment_method = PaymentMethodFactory.create(customer=customer) transaction = TransactionFactory.create(payment_method=payment_method) expected = self._transaction_data(transaction) with patch('silver.utils.payments._get_jwt_token') as mocked_token: mocked_token.return_value = 'token' 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_create_one_without_required_fields(self): customer = CustomerFactory.create() payment_method = PaymentMethodFactory.create(customer=customer) valid_until = datetime.now().replace(microsecond=0) 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_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().replace(microsecond=0) 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_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_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', kwargs={ "payment_method_id": payment_method.pk, "customer_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_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_exception_logging(self, mock_logger): payment_method = PaymentMethodFactory.create( payment_processor=triggered_processor, verified=True) transaction = 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.', transaction.id, exc_info=True) self.assertEqual(expected_call, mock_logger.call_args)
def test_list_transactions(self): customer = CustomerFactory.create() payment_method = PaymentMethodFactory.create(customer=customer) transaction_1 = TransactionFactory.create(payment_method=payment_method) expected_t1 = self._transaction_data(transaction_1) transaction_2 = TransactionFactory.create(payment_method=payment_method) expected_t2 = self._transaction_data(transaction_2) with patch('silver.utils.payments._get_jwt_token') as mocked_token: mocked_token.return_value = 'token' url = reverse('transaction-list', kwargs={'customer_pk': customer.pk}) response = self.client.get(url, format='json') self.assertEqual(response.data[1], expected_t1) self.assertEqual(response.data[0], expected_t2)
def test_transaction_update_status_exception_logging(self, mock_logger): payment_method = PaymentMethodFactory.create( payment_processor=triggered_processor) transaction = 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.', transaction.id, exc_info=True) self.assertEqual(expected_call, mock_logger.call_args)
def test_patch_transaction_with_initial_status(self): payment_method = PaymentMethodFactory.create( payment_processor=triggered_processor) transaction = TransactionFactory.create(payment_method=payment_method) url = reverse('transaction-detail', args=[transaction.customer.pk, transaction.uuid]) valid_until = timezone.now().replace(microsecond=0) data = { 'valid_until': valid_until, } response = self.client.patch(url, format='json', data=data) self.assertEqual( response.status_code, status.HTTP_200_OK, "status %s, data %s" % (response.status_code, response.data)) transaction.refresh_from_db() self.assertEqual(transaction.valid_until, valid_until)