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