def test_connected_account_add_payment_method(a_retrieve, a_update, l_create,
managed_account, api_client):
api_client.force_authenticate(managed_account.owner)
data = {
"external_account": "fkdsla;jfioewni3o2ndsa",
"email": "*****@*****.**",
"legal_entity": {
"first_name": "ted",
"last_name": "bed"
}
}
updated_data = data.copy()
updated_data.pop("external_account")
a_retrieve.return_value = get_mock_resource("Account", managed=True)
a_update.return_value = get_mock_resource("Account",
managed=True,
**updated_data)
l_create.return_value = get_mock_resource("BankAccount")
uri = reverse("rf_stripe:connected-account-detail",
kwargs={"pk": managed_account.pk})
response = api_client.patch(uri, data=data, format="json")
assert response.status_code == 200, response.data
assert 0 < models.BankAccount.objects.filter(
owner=managed_account.owner).count()
def test_account_delete(account_retrieve, account_delete, user, api_client):
api_client.force_authenticate(user)
account_retrieve.return_value = get_mock_resource("Account", managed=True)
account_delete.return_value = None # no one cares about this value... EVER
account = mommy.make(models.ConnectedAccount, owner=user, managed=True,
source=get_mock_resource("Account", managed=True))
uri = reverse("rf_stripe:connected-account-detail", kwargs={"pk": account.pk})
response = api_client.delete(uri)
assert response.status_code == 204
assert not models.ConnectedAccount.objects.filter(id=account.id).exists()
def test_create_stripe_card(card_create, customer_retrieve, customer,
api_client):
api_client.force_authenticate(customer.owner)
uri = reverse("rf_stripe:card-list")
data = {"token": "jflkd;sajfdksa;"}
card_create.return_value = get_mock_resource("Card")
customer_retrieve.return_value = get_mock_resource("Customer")
response = api_client.post(uri, data=data, format="json")
assert response.status_code == 201, "Request failed!"
assert 0 < customer.owner.stripe_cards.count()
def test_create_merchant_stripe_card(card_create, account_retrieve,
managed_account, api_client):
api_client.force_authenticate(managed_account.owner)
uri = reverse("rf_stripe:card-list")
data = {"token": "jflkd;sajfdksa;", "type": "merchant"}
card_create.return_value = get_mock_resource("Card")
account_retrieve.return_value = get_mock_resource("Account", managed=True)
response = api_client.post(uri, data=data, format="json")
assert response.status_code == 201, "Request failed!"
assert 0 < managed_account.owner.stripe_cards.count()
def test_create_subscription(create_sub, retrieve_customer, plan, customer, api_client):
create_sub.return_value = get_mock_resource("Subscription", plan=plan.source)
retrieve_customer.return_value = get_mock_resource("Customer")
api_client.force_authenticate(customer.owner)
data = {
"plan": plan.id,
"coupon": None
}
uri = reverse("rf_stripe:subscription-list")
response = api_client.post(uri, data=data, format="json")
assert response.status_code == 201, response.data
assert 0 < customer.owner.stripe_subscriptions.count()
def test_create_subscription(create_sub, retrieve_customer, plan, customer, api_client):
create_sub.return_value = get_mock_resource("Subscription", plan=plan.source)
retrieve_customer.return_value = get_mock_resource("Customer")
api_client.force_authenticate(customer.owner)
data = {
"plan": plan.id,
"coupon": None
}
uri = reverse("rf_stripe:subscription-list")
response = api_client.post(uri, data=data, format="json")
assert response.status_code == 201, response.data
assert 0 < customer.owner.stripe_subscriptions.count()
def test_create_stripe_card(card_create, customer_retrieve, customer,
api_client):
api_client.force_authenticate(customer.owner)
uri = reverse("rf_stripe:card-list")
data = {
"token": "jflkd;sajfdksa;"
}
card_create.return_value = get_mock_resource("Card")
customer_retrieve.return_value = get_mock_resource("Customer")
response = api_client.post(uri, data=data, format="json")
assert response.status_code == 201, "Request failed!"
assert 0 < customer.owner.stripe_cards.count()
def test_update_connected_account(account_retrieve, account_update,
managed_account, api_client):
api_client.force_authenticate(managed_account.owner)
data = managed_account.source
data.update({"business_name": "targus"})
account_retrieve.return_value = get_mock_resource("Account", managed=True)
account_update.return_value = get_mock_resource("Account", **data)
uri = reverse("rf_stripe:connected-account-detail",
kwargs={"pk": managed_account.pk})
response = api_client.put(uri, data=data, format="json")
assert response.status_code == 200, response.data
assert response.data["owner"] == managed_account.owner.id
assert response.data["source"]["business_name"] == data["business_name"]
def test_bank_account_update(bank_account_retrieve, bank_account_update, bank_account,
api_client):
api_client.force_authenticate(bank_account.owner)
data = {
"default_for_currency": True,
}
bank_account_retrieve.return_value = get_mock_resource("BankAccount")
bank_account_update.return_value = get_mock_resource("BankAccount", **data)
uri = reverse("rf_stripe:bank-account-detail", kwargs={"pk": bank_account.pk})
response = api_client.patch(uri, data=data, format="json")
bank_account.refresh_from_db()
assert response.status_code == 200, response.data
assert bank_account.source["default_for_currency"] is True
def test_account_delete(account_retrieve, account_delete, user, api_client):
api_client.force_authenticate(user)
account_retrieve.return_value = get_mock_resource("Account", managed=True)
account_delete.return_value = None # no one cares about this value... EVER
account = mommy.make(models.ConnectedAccount,
owner=user,
managed=True,
source=get_mock_resource("Account", managed=True))
uri = reverse("rf_stripe:connected-account-detail",
kwargs={"pk": account.pk})
response = api_client.delete(uri)
assert response.status_code == 204
assert not models.ConnectedAccount.objects.filter(id=account.id).exists()
def test_bank_account_update(
bank_account_retrieve,
bank_account_update,
account_retrieve,
bank_account,
managed_account,
api_client):
bank_account.owner = managed_account.owner
bank_account.save()
api_client.force_authenticate(bank_account.owner)
data = {
"default_for_currency": True,
}
bank_account_retrieve.return_value = bank_account.source
bank_account_update.return_value = get_mock_resource("BankAccount", **data)
account_retrieve.return_value = managed_account.source
uri = reverse("rf_stripe:bank-account-detail", kwargs={"pk": bank_account.pk})
response = api_client.patch(uri, data=data, format="json")
bank_account.refresh_from_db()
assert response.status_code == 200, response.data
assert bank_account.source["default_for_currency"] is True
def test_managed_account_adding_bank_account(account_retrieve_mock, ba_create_mock,
managed_account, api_client):
api_client.force_authenticate(managed_account.owner)
account_retrieve_mock.return_value = get_mock_resource("Account", managed=True)
ba_create_mock.return_value = get_mock_resource("BankAccount")
data = {
"token": "tok_dfsjio23jhOFio23",
"type": "merchant"
}
uri = reverse("rf_stripe:bank-account-list")
response = api_client.post(uri, data=data, format="json")
assert response.status_code == 201, response.data
assert response.data["owner"] == managed_account.owner.id
def test_update_subscription(
sub_retrieve,
sub_update,
customer_retrieve,
customer,
subscription,
api_client,
coupon):
subscription.owner = customer.owner
subscription.save()
api_client.force_authenticate(customer.owner)
data = {
"coupon": coupon.id
}
customer_retrieve.return_value = customer.source
sub_retrieve.return_value = subscription.source
sub_update.return_value = get_mock_resource("Subscription",
plan=subscription.plan.source,
discount={"coupon": coupon.source})
uri = reverse("rf_stripe:subscription-detail", kwargs={"pk": subscription.pk})
response = api_client.patch(uri, data=data, format="json")
assert response.status_code == 200, response.data
def test_card_update(
card_retrieve,
card_update,
customer_retrieve,
customer,
card,
api_client):
card.owner = customer.owner
card.source.pop("account", None)
card.source["customer"] = customer.stripe_id
card.save()
api_client.force_authenticate(card.owner)
data = {
"name": "Hans Solo",
"exp_month": 1,
"exp_year": 2019
}
customer_retrieve.return_value = customer.source
card_retrieve.return_value = card.source
card_update.return_value = get_mock_resource("Card", **data)
uri = reverse("rf_stripe:card-detail", kwargs={"pk": card.pk})
response = api_client.patch(uri, data=data, format="json")
card.refresh_from_db()
assert response.status_code == 200
assert card.source["name"] == data["name"]
assert card.source["exp_month"] == data["exp_month"]
assert card.source["exp_year"] == data["exp_year"]
def test_creating_refund(create_refund, charge):
create_refund.return_value = get_mock_resource(
"Refund", amount=charge.source["amount"], charge=charge.stripe_id)
refund = models.Refund(charge=charge,
amount=charge.source["amount"],
reason=models.Refund.DUPLICATE)
refund.save()
def test_create_merchant_stripe_card(card_create, account_retrieve,
managed_account, api_client):
api_client.force_authenticate(managed_account.owner)
uri = reverse("rf_stripe:card-list")
data = {
"token": "jflkd;sajfdksa;",
"type": "merchant"
}
card_create.return_value = get_mock_resource("Card")
account_retrieve.return_value = get_mock_resource("Account", managed=True)
response = api_client.post(uri, data=data, format="json")
assert response.status_code == 201, "Request failed!"
assert 0 < managed_account.owner.stripe_cards.count()
def test_update_connected_account(account_retrieve, account_update, managed_account,
api_client):
api_client.force_authenticate(managed_account.owner)
data = managed_account.source
data.update({
"business_name": "targus"
})
account_retrieve.return_value = get_mock_resource("Account", managed=True)
account_update.return_value = get_mock_resource("Account", **data)
uri = reverse("rf_stripe:connected-account-detail", kwargs={"pk": managed_account.pk})
response = api_client.put(uri, data=data, format="json")
assert response.status_code == 200, response.data
assert response.data["owner"] == managed_account.owner.id
assert response.data["source"]["business_name"] == data["business_name"]
def card(request):
source = get_mock_resource("Card")
card = mommy.make(models.Card, stripe_id=source["id"], source=source)
def fin():
card.delete()
request.addfinalizer(fin)
return card
def transfer(request):
source = get_mock_resource("Transfer")
transfer = mommy.make(models.Transfer, stripe_id=source["id"], source=source)
def fin():
transfer.delete()
request.addfinalizer(fin)
return transfer
def test_creating_refund(create_refund, charge):
create_refund.return_value = get_mock_resource("Refund",
amount=charge.source["amount"], charge=charge.stripe_id)
refund = models.Refund(
charge=charge,
amount=charge.source["amount"],
reason=models.Refund.DUPLICATE
)
refund.save()
def test_customer_update_card(customer_retrieve, customer_update, customer, card, api_client):
card.owner = customer.owner
card.save()
api_client.force_authenticate(customer.owner)
data = {
"default_source": card.id,
"default_source_type": "card"
}
customer_retrieve.return_value = get_mock_resource("Customer")
customer_update.return_value = get_mock_resource("Customer", default_source=card.source)
uri = reverse("rf_stripe:customer-detail", kwargs={"pk": customer.pk})
response = api_client.patch(uri, data=data, format="json")
customer.refresh_from_db()
assert response.status_code == 200, response.data
assert customer.default_source.id == card.id
def charge(request):
source = get_mock_resource("Charge")
charge = mommy.make(models.Charge, stripe_id=source["id"], source=source)
def fin():
charge.delete()
request.addfinalizer(fin)
return charge
def test_customer_adding_bank_account(customer_retrieve_mock, ba_create_mock,
customer, api_client):
api_client.force_authenticate(customer.owner)
customer_retrieve_mock.return_value = get_mock_resource("Customer")
ba_create_mock.return_value = get_mock_resource("BankAccount")
data = {
"token": "tok_dfsjio23jhOFio23",
"type": "customer"
}
uri = reverse("rf_stripe:bank-account-list")
response = api_client.post(uri, data=data, format="json")
assert response.status_code == 201, response.data
assert response.data["owner"] == customer.owner.id
ba = models.BankAccount.objects.get(id=response.data["id"])
assert ba.is_usable
def event(request):
source = get_mock_resource("Event")
event = mommy.make(models.Event, source=source, stripe_id=source["id"],
verified=False, processed=False, event_type=source["type"])
def fin():
event.delete()
request.addfinalizer(fin)
return event
def customer(request):
source = get_mock_resource("Customer")
customer = mommy.make(models.Customer,
stripe_id=source["id"],
source=source
)
def fin():
customer.delete()
request.addfinalizer(fin)
return customer
def bank_account(request):
source = get_mock_resource("BankAccount")
bank_account = mommy.make(models.BankAccount,
stripe_id=source["id"],
source=source
)
def fin():
bank_account.delete()
request.addfinalizer(fin)
return bank_account
def subscription(plan, request):
source = get_mock_resource("Subscription", plan=plan.stripe_id)
subscription = mommy.make(models.Subscription, stripe_id=source["id"],
source=source, plan=plan)
def fin():
subscription.delete()
request.addfinalizer(fin)
return subscription
def test_bank_account_refresh(bank_account_retrieve, bank_account, api_client):
api_client.force_authenticate(bank_account.owner)
bank_account_retrieve.return_value = get_mock_resource("BankAccount",
status="verification_failed")
uri = reverse("rf_stripe:bank-account-refresh", kwargs={"pk": bank_account.pk})
response = api_client.get(uri)
bank_account.refresh_from_db()
assert bank_account.status == "verification_failed"
assert bank_account.is_usable is False
def test_process_event(event_retrieve, event):
event_retrieve.return_value = get_mock_resource("Event")
handler = mock.Mock()
event_type, event_subtype = event.event_type.split(".", 1)
webhooks.register(event_type)(handler)
event.process()
assert event.verified is True
assert event.processed is True
handler.assert_called_with(event, event.source["data"], event_subtype)
def managed_account(request):
source = get_mock_resource("Account", managed=True)
account = mommy.make(models.ConnectedAccount,
stripe_id=source["id"],
managed=True,
source=source
)
def fin():
account.delete()
request.addfinalizer(fin)
return account
def test_process_event(event_retrieve, event):
event_retrieve.return_value = get_mock_resource("Event")
handler = mock.Mock()
event_type, event_subtype = event.event_type.split(".", 1)
webhooks.register(event_type)(handler)
event.process()
assert event.verified is True
assert event.processed is True
handler.assert_called_with(event, event.source["data"], event_subtype)
def test_card_create_error(card_create, customer_retrieve, customer,
api_client):
api_client.force_authenticate(customer.owner)
uri = reverse("rf_stripe:card-list")
data = {"token": "jflkd;sajfdksa;", "type": "customer"}
customer_retrieve.return_value = get_mock_resource("Customer")
card_create.side_effect = stripe.InvalidRequestError(
"invalid token!", "token")
response = api_client.post(uri, data=data, format="json")
assert response.status_code == 400
assert response.data["token"] == "invalid token!"
def test_process_event_error(event_retrieve, event):
event_retrieve.return_value = get_mock_resource("Event")
handler = mock.Mock()
handler.side_effect = stripe.StripeError(message="Bad Request")
event_type, event_subtype = event.event_type.split(".", 1)
webhooks.register(event_type)(handler)
event.process()
assert event.verified is True
assert event.processed is False
handler.assert_called_with(event, event.source["data"], event_subtype)
def test_retrieve_card(customer, api_client):
api_client.force_authenticate(customer.owner)
card = mommy.make(models.Card, owner=customer.owner, cvc_check="fail",
source=get_mock_resource("Card", cvc_check="fail"))
uri = reverse("rf_stripe:card-detail", kwargs={"pk": card.pk})
response = api_client.get(uri)
assert response.status_code == 200
assert response.data["id"] == card.id
assert response.data["owner"] == customer.owner.id
assert response.data["cvc_check"] == "fail"
assert card.is_usable is False
def test_process_event_error(event_retrieve, event):
event_retrieve.return_value = get_mock_resource("Event")
handler = mock.Mock()
handler.side_effect = stripe.StripeError(message="Bad Request")
event_type, event_subtype = event.event_type.split(".", 1)
webhooks.register(event_type)(handler)
event.process()
assert event.verified is True
assert event.processed is False
handler.assert_called_with(event, event.source["data"], event_subtype)
def test_create_transfer(transfer_create, managed_account, bank_account):
kwargs = {"amount": 1000, "currency": "usd", "destination": managed_account.stripe_id}
transfer_create.return_value = get_mock_resource(
"Transfer", bank_account=bank_account.source, source_type="bank_account", type="account", **kwargs
)
stripe_object = models.Transfer.stripe_api_create(**kwargs)
transfer = models.Transfer.stripe_object_to_model(stripe_object)
transfer.owner = managed_account.owner
transfer.save()
assert transfer.succeeded
def test_bank_account_delete(bank_account_retrieve, bank_account_delete, bank_account,
api_client):
user = bank_account.owner
api_client.force_authenticate(user)
bank_account_retrieve.return_value = get_mock_resource("BankAccount")
bank_account_delete.return_value = None # no one cares about this value... EVER
uri = reverse("rf_stripe:bank-account-detail", kwargs={"pk": bank_account.pk})
response = api_client.delete(uri)
assert response.status_code == 204
assert not models.BankAccount.objects.filter(id=bank_account.id).exists()
def refund(charge, request):
source = get_mock_resource("Refund", charge=charge.stripe_id,
amount=charge.source["amount"])
refund = mommy.make(models.Refund,
owner=charge.owner, is_created=True, charge=charge,
reason=models.Refund.DUPLICATE, amount=source["amount"],
stripe_id=source["id"], source=source)
def fin():
refund.delete()
request.addfinalizer(fin)
return refund
def test_plan_manager_create(plan_create_mock):
plan_create_mock.return_value = get_mock_resource("Plan", id="Gold Plan")
plan = models.Plan(
name="Gold Plan",
amount=100,
interval=models.Plan.MONTHLY,
name_on_invoice="Gold Plan Subscription",
statement_descriptor="GOLDPLANSUB",
)
plan.save()
assert plan.stripe_id is not None
assert plan.source is not None
def test_card_create_error(card_create, customer_retrieve, customer, api_client):
api_client.force_authenticate(customer.owner)
uri = reverse("rf_stripe:card-list")
data = {
"token": "jflkd;sajfdksa;",
"type": "customer"
}
customer_retrieve.return_value = get_mock_resource("Customer")
card_create.side_effect = stripe.InvalidRequestError("invalid token!", "token")
response = api_client.post(uri, data=data, format="json")
assert response.status_code == 400
assert response.data["token"] == "invalid token!"
def test_plan_manager_create(plan_create_mock):
plan_create_mock.return_value = get_mock_resource("Plan", id="Gold Plan")
plan = models.Plan(
name="Gold Plan",
amount=100,
interval=models.Plan.MONTHLY,
name_on_invoice="Gold Plan Subscription",
statement_descriptor="GOLDPLANSUB",
)
plan.save()
assert plan.stripe_id is not None
assert plan.source is not None
def plan(request):
source = get_mock_resource("Plan")
plan = mommy.make(models.Plan, stripe_id=source["id"], source=source, is_created=True)
@mock.patch("stripe.Plan.delete")
@mock.patch("stripe.Plan.retrieve")
def fin(ret_plan, del_plan):
ret_plan.return_value = get_mock_resource("Plan")
del_plan.return_value = None
plan.delete()
request.addfinalizer(fin)
return plan
def test_customer_add_payment_method(a_retrieve, a_update, l_create, customer, api_client):
api_client.force_authenticate(customer.owner)
data = {
"source": "fkdsla;jfioewni3o2ndsa",
"email": "*****@*****.**",
}
new_card = get_mock_resource("Card")
updated_data = data.copy()
updated_data.pop("source")
updated_data["default_source"] = new_card
a_retrieve.return_value = get_mock_resource("Customer")
l_create.return_value = new_card
a_update.return_value = get_mock_resource("Customer", **updated_data)
uri = reverse("rf_stripe:customer-detail", kwargs={"pk": customer.pk})
response = api_client.patch(uri, data=data, format="json")
customer.refresh_from_db()
assert response.status_code == 200, response.data
assert 0 < models.Card.objects.filter(owner=customer.owner).count()
assert customer.source["email"] == data["email"]
def test_retrieve_card(customer, api_client):
api_client.force_authenticate(customer.owner)
card = mommy.make(models.Card,
owner=customer.owner,
cvc_check="fail",
source=get_mock_resource("Card", cvc_check="fail"))
uri = reverse("rf_stripe:card-detail", kwargs={"pk": card.pk})
response = api_client.get(uri)
assert response.status_code == 200
assert response.data["id"] == card.id
assert response.data["owner"] == customer.owner.id
assert response.data["cvc_check"] == "fail"
assert card.is_usable is False
def test_update_connected_account_error(account_retrieve, account_update,
managed_account, api_client):
api_client.force_authenticate(managed_account.owner)
data = managed_account.source
data.update({"business_name": "targus"})
account_retrieve.return_value = get_mock_resource("Account", managed=True)
account_update.side_effect = stripe.InvalidRequestError(
param="business_name", message="no targuses allowed!")
uri = reverse("rf_stripe:connected-account-detail",
kwargs={"pk": managed_account.pk})
response = api_client.put(uri, data=data, format="json")
assert response.status_code == 400, response.data
assert response.data["business_name"] == "no targuses allowed!"
def test_create_stripe_bank_account_charge(create_charge, bank_account):
kwargs = {
"amount": 1000,
"currency": "usd",
"source": bank_account.stripe_id,
}
create_charge.return_value = get_mock_resource("Charge",
status="succeeded",
source=bank_account.source,
amount=1000,
currency="usd")
stripe_object = models.Charge.stripe_api_create(**kwargs)
charge_model = models.Charge.stripe_object_to_model(stripe_object)
charge_model.owner = bank_account.owner
charge_model.save()
assert charge_model.succeeded
assert charge_model.retrieve_payment_source().id == bank_account.id
