def refund(charge, amount):
stripe_charge = stripe.Charge(charge.stripe_id)
refund = stripe_charge.refunds.create(amount)
charge.customer.account_balance -= amount
charge.customer.save()
return StripeRefund.objects.create(charge=charge,
stripe_id=refund.stripe_id)
def setUp(self):
super(StripeSourcePaymentAdminTestCase, self).setUp()
account = generate_stripe_payout_account()
bank_account = ExternalAccountFactory.create(connect_account=account)
funding = FundingFactory.create(bank_account=bank_account)
self.client.force_login(self.superuser)
self.donation = DonationFactory(
amount=Money(100, 'EUR'),
activity=funding
)
with patch('stripe.Source.modify'):
self.payment = StripeSourcePaymentFactory.create(
source_token='source-token',
charge_token='charge-token',
donation=self.donation
)
self.admin_url = reverse('admin:funding_stripe_stripesourcepayment_change', args=(self.payment.id,))
self.check_status_url = reverse('admin:funding_payment_check', args=(self.payment.id,))
self.source = stripe.Source('source-token')
self.source.update({
'amount': 10000,
'currency': 'EUR',
'status': 'charged'
})
self.charge = stripe.Charge('charge-token')
self.charge.update({
'status': 'succeeded',
'refunded': None,
'dispute': None
})
def test_source_chargeable(self):
data = {'object': {'id': self.payment.source_token}}
charge = stripe.Charge('some charge token')
charge.update({'status': 'succeeded', 'refunded': False})
with mock.patch('stripe.Webhook.construct_event',
return_value=MockEvent('source.chargeable', data)):
with mock.patch('stripe.Charge.create',
return_value=charge) as create_charge:
response = self.client.post(
self.webhook, HTTP_STRIPE_SIGNATURE='some signature')
create_charge.assert_called_with(
amount=int(self.donation.amount.amount * 100),
currency=self.donation.amount.currency,
metadata={
'tenant_name': u'test',
'activity_id': self.funding.pk,
'activity_title': self.funding.title,
'tenant_domain': u'testserver'
},
source=u'some-source-id',
statement_descriptor_suffix=u'Test',
transfer_data={
'destination':
self.funding.bank_account.connect_account.account_id
})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self._refresh()
self.assertEqual(self.donation.status, 'new')
self.assertEqual(self.payment.status, 'charged')
def test_unset_metadata(self):
charge = stripe.Charge(id='ch_foo')
charge.metadata = {}
charge.save()
self.requestor_mock.request.assert_called_with('post',
'/v1/charges/ch_foo', {
'metadata': {},
})
def test_mark_as_safe(self):
charge = stripe.Charge(id='ch_update_id')
charge.mark_as_safe()
self.requestor_mock.request.assert_called_with(
'post', '/v1/charges/ch_update_id',
{'fraud_details': {
'user_report': 'safe'
}})
def test_noop_metadata(self):
charge = stripe.Charge(id='ch_foo')
charge.description = 'test'
charge.save()
self.requestor_mock.request.assert_called_with(
'post', '/v1/charges/ch_foo', {
'description': 'test',
})
def test_charge_close_dispute(self):
charge = stripe.Charge(id='ch_update_id')
charge.close_dispute(idempotency_key='foo')
self.requestor_mock.request.assert_called_with(
'post',
'/v1/charges/ch_update_id/dispute/close',
{},
{'Idempotency-Key': 'foo'},
)
def test_whole_update(self):
charge = stripe.Charge(id='ch_foo')
charge.metadata = {'whole': 'update'}
charge.save()
self.requestor_mock.request.assert_called_with(
'post', '/v1/charges/ch_foo', {
'metadata': {
'whole': 'update'
},
})
def test_individual_delete(self):
charge = stripe.Charge(id='ch_foo')
charge.metadata = {'whole': None}
charge.save()
self.requestor_mock.request.assert_called_with('post',
'/v1/charges/ch_foo', {
'metadata': {
'whole': None
},
})
def test_charge_log_transaction_no_unpaid(self, monkeypatch):
group = Group()
monkeypatch.setattr(Group, 'amount_unpaid', 0)
charge = Charge(targets=[group], amount=1000,
description="Test charge")
charge.response = stripe.Charge(id=10)
txn = charge.stripe_transaction_from_charge()
result = charge.stripe_transaction_for_model(group, txn)
assert result.group_id == group.id
assert result.txn_id == txn.id
assert result.share == 1000
def test_charge_log_transaction_attendee(self, monkeypatch):
attendee = Attendee()
monkeypatch.setattr(Attendee, 'amount_unpaid', 10)
charge = Charge(targets=[attendee],
description="Test charge")
charge.response = stripe.Charge(id=10)
txn = charge.stripe_transaction_from_charge()
result = charge.stripe_transaction_for_model(attendee, txn)
assert result.attendee_id == attendee.id
assert result.txn_id == txn.id
assert result.share == 1000
def test_charge_log_transaction(self, monkeypatch):
attendee = Attendee()
monkeypatch.setattr(Attendee, 'amount_unpaid', 10)
charge = Charge(targets=[attendee], amount=1000, description="Test charge")
charge.response = stripe.Charge(id=10)
result = charge.stripe_transaction_from_charge()
assert result.stripe_id == 10
assert result.amount == 1000
assert result.desc == "Test charge"
assert result.type == c.PAYMENT
assert result.who == 'non-admin'
def test_charge_log_transaction(self):
attendee = Attendee()
charge = Charge(targets=[attendee], amount=1000, description="Test charge")
charge.response = stripe.Charge(id=10)
result = charge.stripe_transaction_from_charge()
assert result.stripe_id == 10
assert result.amount == 1000
assert result.desc == "Test charge"
assert result.type == c.PAYMENT
assert result.who == 'non-admin'
assert result.fk_id == attendee.id
assert result.fk_model == attendee.__class__.__name__
def test_mark_as_fraudulent(self):
charge = stripe.Charge(id='ch_update_id')
charge.mark_as_fraudulent(idempotency_key='foo')
self.requestor_mock.request.assert_called_with(
'post',
'/v1/charges/ch_update_id',
{'fraud_details': {
'user_report': 'fraudulent'
}},
{'Idempotency-Key': 'foo'},
)
def test_already_charged(self, charge_create_mocked):
charge_create_mocked.return_value = stripe.Charge(id="AA1")
self.charge.charge()
self.assertTrue(self.charge.is_charged)
self.assertTrue(self.success_signal_was_called)
self.assertFalse(self.exception_signal_was_called)
self._reset_signals()
with self.assertRaises(StripeMethodNotAllowed) as ctx:
self.charge.charge()
self.assertEqual(ctx.exception.args[0], "Already charged.")
self.assertTrue(self.charge.is_charged)
self.assertFalse(self.success_signal_was_called)
self.assertFalse(self.exception_signal_was_called)
def create_charge(self, amount, currency="usd", customer=None, card=None, description=None ):
# https://stripe.com/docs/api?lang=python#create_charge
# customer.id or card required but not both
# charge the Customer instead of the card
# amount in cents
charge = stripe.Charge(api_key=self.api_key).create(
amount=int(100*amount), # in cents
currency=currency,
customer=customer,
card=card,
description=description
)
return charge
def test_refund(self):
self.payment.states.succeed(save=True)
payment_intent = stripe.PaymentIntent('some intent id')
charge = stripe.Charge('charge-id')
charges = stripe.ListObject()
charges.data = [charge]
payment_intent.charges = charges
with mock.patch('stripe.PaymentIntent.retrieve',
return_value=payment_intent):
with mock.patch('stripe.Charge.refund') as refund_mock:
self.payment.states.request_refund(save=True)
self.assertTrue(refund_mock.called_once)
def capture(charge, amount=None, idempotency_key=None):
"""
Capture the payment of an existing, uncaptured, charge.
Args:
charge: a pinax.stripe.models.Charge object
amount: the decimal.Decimal amount of the charge to capture
"""
amount = utils.convert_amount_for_api(
amount if amount else charge.amount,
charge.currency
)
stripe_charge = stripe.Charge(charge.stripe_id).capture(
amount=amount,
idempotency_key=idempotency_key,
expand=["balance_transaction"],
)
sync_charge_from_stripe_data(stripe_charge)
def test_charge_with_idempotency_key(self, charge_create_mocked):
charge_create_mocked.return_value = stripe.Charge(id="AA1")
idempotency_key = "idempotency_key123"
self.charge.charge(idempotency_key=idempotency_key)
self.assertTrue(self.charge.is_charged)
self.assertTrue(self.success_signal_was_called)
self.assertFalse(self.exception_signal_was_called)
self.assertEqual(self.charge.stripe_response["id"], "AA1")
charge_create_mocked.assert_called_with(
idempotency_key="{}-{}-{}".format(self.charge.object_id,
self.charge.content_type_id,
idempotency_key),
amount=self.charge.amount,
currency=self.data["currency"],
customer=self.data["customer_id"],
description=self.data["description"],
metadata={
"object_id": self.charge.object_id,
"content_type_id": self.charge.content_type_id,
},
)
def test_charges(self, charge_create_mocked):
self.success_signal_was_called = False
self.exception_signal_was_called = False
def success_handler(sender, instance, **kwargs):
self.success_signal_was_called = True
def exception_handler(sender, instance, **kwargs):
self.exception_signal_was_called = True
stripe_charge_succeeded.connect(success_handler)
stripe_charge_card_exception.connect(exception_handler)
data = {
"customer_id": "cus_AlSWz1ZQw7qG2z",
"currency": "usd",
"amount": 100,
"description": "ABC"
}
charge_create_mocked.return_value = stripe.Charge(id="AA1")
StripeCustomer.objects.create(user=self.user,
stripe_customer_id="bum",
stripe_js_response='"aa"')
StripeCustomer.objects.create(user=self.user,
stripe_customer_id=data["customer_id"],
stripe_js_response='"foo"')
customer = StripeCustomer.objects.create(
user=self.user,
stripe_customer_id=data["customer_id"],
stripe_js_response='"foo"')
self.assertTrue(
customer,
StripeCustomer.get_latest_active_customer_for_user(self.user))
charge = StripeCharge.objects.create(user=self.user,
amount=data["amount"],
customer=customer,
description=data["description"])
manual_charge = StripeCharge.objects.create(
user=self.user,
amount=data["amount"],
customer=customer,
description=data["description"])
self.assertFalse(charge.is_charged)
# test in case of an API error
charge_create_mocked.side_effect = StripeError()
with self.assertRaises(SystemExit):
out = StringIO()
sys.stdout = out
call_command('charge_stripe')
self.assertFalse(self.success_signal_was_called)
charge.refresh_from_db()
self.assertFalse(charge.is_charged)
self.assertIn('Exception happened', out.getvalue())
charge_create_mocked.reset_mock()
charge_create_mocked.side_effect = CardError(message="a",
param="b",
code="c")
# test regular case
call_command("charge_stripe")
self.assertTrue(self.exception_signal_was_called)
charge.refresh_from_db()
self.assertFalse(charge.is_charged)
self.assertTrue(charge.charge_attempt_failed)
charge_create_mocked.reset_mock()
charge_create_mocked.side_effect = None
# test regular case
# reset charge
charge.charge_attempt_failed = False
charge.save()
call_command("charge_stripe")
self.assertTrue(self.success_signal_was_called)
charge.refresh_from_db()
self.assertTrue(charge.is_charged)
manual_charge.refresh_from_db()
self.assertFalse(manual_charge.is_charged)
self.assertEqual(charge.stripe_response["id"], "AA1")
charge_create_mocked.assert_called_with(
amount=charge.amount,
currency=data["currency"],
customer=data["customer_id"],
description=data["description"])
# manual call
manual_charge.charge()
self.assertTrue(manual_charge.is_charged)
def refund_charge(self, charge_id):
# https://stripe.com/docs/api?lang=python#refund_charge
ch = stripe.Charge(api_key=self.api_key).retrieve(charge_id)
ch.refund()
return ch
def charge(self):
return stripe.Charge(api_key=self.api_key)
def create(**kw):
assert kw['card'] == 'stripeToken'
assert kw['description'] == self.purchase.invoiceUrl[0]
charge = stripe.Charge()
charge.update(dict(id='stripe_id', created=1, paid=True, **kw))
return charge
def build_full_manual_refunded_charge():
# can't find a way to make this inline - stripe.Charge(amount_refunded=10) does not work
sc = stripe.Charge(id="AA1")
sc.amount_refunded = 100
return sc
def test_charge_close_dispute(self):
charge = stripe.Charge(id='ch_update_id')
charge.close_dispute()
self.requestor_mock.request.assert_called_with(
'post', '/v1/charges/ch_update_id/dispute/close', {})
