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