Пример #1
0
	def test_cancel_and_reactivate(
		self,
		customer_retrieve_mock,
		subscription_retrieve_mock,
		product_retrieve_mock,
		plan_retrieve_mock,
	):
		current_period_end = timezone.now() + timezone.timedelta(days=7)

		subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		subscription = Subscription.sync_from_stripe_data(subscription_fake)
		subscription.current_period_end = current_period_end
		subscription.save()

		canceled_subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		canceled_subscription_fake["current_period_end"] = datetime_to_unix(
			current_period_end
		)
		canceled_subscription_fake["canceled_at"] = datetime_to_unix(timezone.now())
		subscription_retrieve_mock.return_value = canceled_subscription_fake

		self.assertTrue(self.customer.has_active_subscription())
		self.assertTrue(self.customer.has_any_active_subscription())

		new_subscription = subscription.cancel(at_period_end=True)
		self.assertEqual(new_subscription.cancel_at_period_end, True)

		new_subscription.reactivate()
		subscription_reactivate_fake = deepcopy(FAKE_SUBSCRIPTION)
		reactivated_subscription = Subscription.sync_from_stripe_data(
			subscription_reactivate_fake
		)
		self.assertEqual(reactivated_subscription.cancel_at_period_end, False)

		self.assert_fks(subscription, expected_blank_fks={"djstripe.Customer.coupon"})
Пример #2
0
    def test_cancel_subscription(self, cancel_subscription_mock):
        """Test a DELETE to the SubscriptionRestView.

        Should cancel a Customer objects subscription.
        """
        def _cancel_sub(*args, **kwargs):
            subscription = Subscription.objects.first()
            subscription.status = SubscriptionStatus.canceled
            subscription.canceled_at = timezone.now()
            subscription.ended_at = timezone.now()
            subscription.save()
            return subscription

        fake_cancelled_subscription = deepcopy(FAKE_SUBSCRIPTION)
        Subscription.sync_from_stripe_data(fake_cancelled_subscription)

        cancel_subscription_mock.side_effect = _cancel_sub

        self.assertEqual(1, Subscription.objects.count())
        self.assertEqual(Subscription.objects.first().status, SubscriptionStatus.active)

        response = self.client.delete(self.url)
        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)

        # Cancelled means flagged as cancelled, so it should still be there
        self.assertEqual(1, Subscription.objects.count())
        self.assertEqual(Subscription.objects.first().status, SubscriptionStatus.canceled)

        cancel_subscription_mock.assert_called_once_with(
            at_period_end=djstripe_settings.CANCELLATION_AT_PERIOD_END
        )
        self.assertTrue(self.user.is_authenticated)
def resync_subscriptions(apps, schema_editor):
    """
    Since subscription IDs were not previously stored, a direct migration will leave us
    with a bunch of orphaned objects. It was decided [here](https://github.com/kavdev/dj-stripe/issues/162)
    that a purge and re-sync would be the best option. No data that is currently available on stripe will
    be deleted. Anything stored locally will be purged.
    """

    # This is okay, since we're only doing a forward migration.
    from djstripe.models import Subscription

    from djstripe.context_managers import stripe_temporary_api_version

    with stripe_temporary_api_version("2016-03-07"):
        if Subscription.objects.count():
            print("Purging subscriptions. Don't worry, all active subscriptions will be re-synced from stripe. Just in \
            case you didn't get the memo, we'll print out a json representation of each object for your records:")
            print(serializers.serialize("json", Subscription.objects.all()))
            Subscription.objects.all().delete()

            print("Re-syncing subscriptions. This may take a while.")

            for stripe_subscription in tqdm(iterable=Subscription.api_list(), desc="Sync", unit=" subscriptions"):
                subscription = Subscription.sync_from_stripe_data(stripe_subscription)

                if not subscription.customer:
                    tqdm.write("The customer for this subscription ({subscription_id}) does not exist locally (so we \
                    won't sync the subscription). You'll want to figure out how that \
                    happened.".format(subscription_id=stripe_subscription['id']))

            print("Subscription re-sync complete.")
Пример #4
0
    def test_remove_all_multi_plan(
        self,
        subscription_retrieve_mock,
        customer_retrieve_mock,
        product_retrieve_mock,
        plan_retrieve_mock,
    ):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION_MULTI_PLAN)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        self.assertIsNone(subscription.plan)
        self.assertIsNone(subscription.quantity)

        items = subscription.items.all()
        self.assertEqual(2, len(items))

        # Simulate a webhook received with no more plan
        del subscription_fake["items"]["data"][1]
        del subscription_fake["items"]["data"][0]
        subscription_fake["items"]["total_count"] = 0

        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        items = subscription.items.all()
        self.assertEqual(0, len(items))

        self.assert_fks(
            subscription,
            expected_blank_fks=self.default_expected_blank_fks
            | {"djstripe.Customer.subscriber", "djstripe.Subscription.plan"},
        )
Пример #5
0
	def test_should_apply_to_true_stripe(self, user):
		customer = Customer.objects.create(
			stripe_id="cust_TEST",
			account_balance=0,
			delinquent=False,
			subscriber=user
		)
		plan = Plan.objects.create(
			stripe_id="plan_TEST",
			amount=0,
			currency="USD",
			interval=PlanInterval.month
		)
		subscription = Subscription(
			current_period_end=timezone.now() + timedelta(days=7),
			current_period_start=timezone.now() - timedelta(days=7),
			customer=customer,
			quantity=1,
			plan=plan,
			start=timezone.now() - timedelta(days=7),
			status="active"
		)
		subscription.save()

		user.djstripe_customers.add(customer)

		assert self.tag.should_apply_to(user)
Пример #6
0
	def test_cancel_and_reactivate(
		self, customer_retrieve_mock, subscription_retrieve_mock, plan_retrieve_mock
	):
		current_period_end = timezone.now() + timezone.timedelta(days=7)

		subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		subscription = Subscription.sync_from_stripe_data(subscription_fake)
		subscription.current_period_end = current_period_end
		subscription.save()

		canceled_subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		canceled_subscription_fake["current_period_end"] = datetime_to_unix(
			current_period_end
		)
		canceled_subscription_fake["canceled_at"] = datetime_to_unix(timezone.now())
		subscription_retrieve_mock.return_value = canceled_subscription_fake

		self.assertTrue(self.customer.has_active_subscription())
		self.assertTrue(self.customer.has_any_active_subscription())

		new_subscription = subscription.cancel(at_period_end=True)
		self.assertEqual(new_subscription.cancel_at_period_end, True)

		new_subscription.reactivate()
		subscription_reactivate_fake = deepcopy(FAKE_SUBSCRIPTION)
		reactivated_subscription = Subscription.sync_from_stripe_data(
			subscription_reactivate_fake
		)
		self.assertEqual(reactivated_subscription.cancel_at_period_end, False)

		self.assert_fks(
			subscription,
			expected_blank_fks={"djstripe.Customer.coupon", "djstripe.Plan.product"},
		)
Пример #7
0
def manage_subscription(request):
    #First get user specific subscription;
    ''''
    user=User.objects.get(username=request.user.username)
    subscription = SubscriberSubscriptionDetails.objects.get(user=user)
    djstripes=djstripe.models.Subscription.objects.get(pk=subscription.subscription_id)

    cancel_my_subscription=stripe.Subscription.delete(djstripes.id)
    djstripe.models.Subscription.sync_from_stripe_data(cancel_my_subscription)
    messages.success(request,'Your subscription has been cancelled successfully')
    '''
    user = User.objects.get(username=request.user.username)
    status='not subscribed'
    try:
        subscription = SubscriberSubscriptionDetails.objects.filter(user=user).latest('date_subscribed')
        djstripes = Subscription.objects.get(pk=subscription.subscription_id)
        status=djstripes.status
    except SubscriberSubscriptionDetails.DoesNotExist:
        subscription=None
    if request.method == 'POST':
        cancel_my_subscription = stripe.Subscription.delete(djstripes.id)
        Subscription.sync_from_stripe_data(cancel_my_subscription)
        messages.success(request, 'Your subscription has been cancelled successfully')




    return render(request,'subscriber/manage_subscriptions.html',{'s_status':status})
Пример #8
0
    def test_cancel_subscription(self, cancel_subscription_mock):
        """Test a DELETE to the SubscriptionRestView.

        Should cancel a Customer objects subscription.
        """
        def _cancel_sub(*args, **kwargs):
            subscription = Subscription.objects.first()
            subscription.status = SubscriptionStatus.canceled
            subscription.canceled_at = timezone.now()
            subscription.ended_at = timezone.now()
            subscription.save()
            return subscription

        fake_cancelled_subscription = deepcopy(FAKE_SUBSCRIPTION)
        Subscription.sync_from_stripe_data(fake_cancelled_subscription)

        cancel_subscription_mock.side_effect = _cancel_sub

        self.assertEqual(1, Subscription.objects.count())
        self.assertEqual(Subscription.objects.first().status,
                         SubscriptionStatus.active)

        response = self.client.delete(self.url)
        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)

        # Cancelled means flagged as cancelled, so it should still be there
        self.assertEqual(1, Subscription.objects.count())
        self.assertEqual(Subscription.objects.first().status,
                         SubscriptionStatus.canceled)

        cancel_subscription_mock.assert_called_once_with(
            at_period_end=djstripe_settings.CANCELLATION_AT_PERIOD_END)
        self.assertTrue(self.user.is_authenticated)
Пример #9
0
    def test_cancel_at_period_end(self, cancel_subscription_mock, customer_retrieve_mock):
        Subscription.sync_from_stripe_data(FAKE_SUBSCRIPTION)

        response = self.client.post(self.url)

        cancel_subscription_mock.assert_called_once_with(at_period_end=True)
        self.assertRedirects(response, reverse("home"))
        self.assertTrue(self.user.is_authenticated)
Пример #10
0
    def test_cancel_at_period_end(self, cancel_subscription_mock, customer_retrieve_mock):
        Subscription.sync_from_stripe_data(FAKE_SUBSCRIPTION)

        response = self.client.post(self.url)

        cancel_subscription_mock.assert_called_once_with(at_period_end=True)
        self.assertRedirects(response, reverse("home"))
        self.assertTrue(self.user.is_authenticated)
Пример #11
0
    def test_cancel_at_period_end(self, cancel_subscription_mock):
        Customer.objects.create(subscriber=self.user, stripe_id=FAKE_CUSTOMER["id"], livemode=False)
        Subscription.sync_from_stripe_data(FAKE_SUBSCRIPTION)

        response = self.client.post(self.url)

        cancel_subscription_mock.assert_called_once_with(at_period_end=True)
        self.assertRedirects(response, reverse("home"))
        self.assertTrue(self.user.is_authenticated())
Пример #12
0
    def test_cancel_next_url(self, cancel_subscription_mock, customer_retrieve_mock):
        Subscription.sync_from_stripe_data(FAKE_SUBSCRIPTION)

        response = self.client.post(self.url + "?next=/test")

        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, "/test")

        self.assertTrue(get_user(self.client).is_anonymous)
Пример #13
0
    def test_cancel_next_url(self, cancel_subscription_mock, customer_retrieve_mock):
        Subscription.sync_from_stripe_data(FAKE_SUBSCRIPTION)

        response = self.client.post(self.url + "?next=/test")

        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, "/test")

        self.assertTrue(get_user(self.client).is_anonymous)
Пример #14
0
    def test_remove_all_multi_plan(
        self,
        subscription_retrieve_mock,
        customer_retrieve_mock,
        product_retrieve_mock,
        plan_retrieve_mock,
        invoice_retrieve_mock,
        paymentintent_retrieve_mock,
        paymentmethod_retrieve_mock,
        charge_retrieve_mock,
        balance_transaction_retrieve_mock,
    ):
        # delete pydanny customer as that causes issues with Invoice and Latest_invoice FKs
        self.customer.delete()

        fake_payment_intent = deepcopy(FAKE_PAYMENT_INTENT_II)
        fake_payment_intent["invoice"] = FAKE_INVOICE_II["id"]
        paymentintent_retrieve_mock.return_value = fake_payment_intent

        fake_subscription = deepcopy(FAKE_SUBSCRIPTION_MULTI_PLAN)
        fake_subscription["latest_invoice"] = FAKE_INVOICE_II["id"]
        subscription_retrieve_mock.return_value = fake_subscription

        fake_charge = deepcopy(FAKE_CHARGE_II)
        fake_charge["payment_method"] = FAKE_PAYMENT_METHOD_II["id"]
        charge_retrieve_mock.return_value = fake_charge

        # create invoice
        fake_invoice = deepcopy(FAKE_INVOICE_II)
        Invoice.sync_from_stripe_data(fake_invoice)

        subscription = Subscription.sync_from_stripe_data(fake_subscription)

        self.assertIsNone(subscription.plan)
        self.assertIsNone(subscription.quantity)

        items = subscription.items.all()
        self.assertEqual(2, len(items))

        # Simulate a webhook received with no more plan
        del fake_subscription["items"]["data"][1]
        del fake_subscription["items"]["data"][0]
        fake_subscription["items"]["total_count"] = 0

        subscription = Subscription.sync_from_stripe_data(fake_subscription)
        items = subscription.items.all()
        self.assertEqual(0, len(items))

        self.assert_fks(
            subscription,
            expected_blank_fks=self.default_expected_blank_fks
            | {
                "djstripe.Customer.subscriber",
                "djstripe.Subscription.plan",
            },
        )
Пример #15
0
    def test_cancel_next_url(self, cancel_subscription_mock):
        Customer.objects.create(subscriber=self.user, stripe_id=FAKE_CUSTOMER["id"], livemode=False)
        Subscription.sync_from_stripe_data(FAKE_SUBSCRIPTION)

        response = self.client.post(self.url + "?next=/test")

        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, "/test")

        self.assertTrue(get_user(self.client).is_anonymous)
Пример #16
0
    def test_update_multi_plan(
        self,
        subscription_retrieve_mock,
        customer_retrieve_mock,
        product_retrieve_mock,
        plan_retrieve_mock,
    ):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION_MULTI_PLAN)
        subscription_fake["latest_invoice"] = FAKE_INVOICE["id"]
        subscription_retrieve_mock.return_value = subscription_fake

        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        self.assertIsNone(subscription.plan)
        self.assertIsNone(subscription.quantity)

        items = subscription.items.all()
        self.assertEqual(2, len(items))

        # Simulate a webhook received with one plan that has been removed
        del subscription_fake["items"]["data"][1]
        subscription_fake["items"]["total_count"] = 1

        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        items = subscription.items.all()
        self.assertEqual(1, len(items))

        # delete pydanny customer as that causes issues with Invoice and Latest_invoice FKs
        self.customer.delete()

        self.assert_fks(
            subscription,
            expected_blank_fks=(
                self.default_expected_blank_fks
                | {
                    "djstripe.Customer.subscriber",
                    "djstripe.Subscription.plan",
                    "djstripe.Charge.latest_upcominginvoice (related name)",
                    "djstripe.Charge.application_fee",
                    "djstripe.Charge.dispute",
                    "djstripe.Charge.on_behalf_of",
                    "djstripe.Charge.source_transfer",
                    "djstripe.Charge.transfer",
                    "djstripe.PaymentIntent.upcominginvoice (related name)",
                    "djstripe.PaymentIntent.on_behalf_of",
                    "djstripe.PaymentIntent.payment_method",
                    "djstripe.Invoice.default_payment_method",
                    "djstripe.Invoice.default_source",
                    "djstripe.Invoice.charge",
                    "djstripe.Invoice.customer",
                    "djstripe.Invoice.payment_intent",
                    "djstripe.Invoice.subscription",
                }),
        )
Пример #17
0
	def test_extend(
		self,
		customer_retrieve_mock,
		subscription_retrieve_mock,
		product_retrieve_mock,
		plan_retrieve_mock,
	):
		subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		subscription_fake["current_period_end"] = datetime_to_unix(
			timezone.now() - timezone.timedelta(days=20)
		)

		subscription_retrieve_mock.return_value = subscription_fake

		subscription = Subscription.sync_from_stripe_data(subscription_fake)
		self.assertFalse(subscription in self.customer.active_subscriptions)
		self.assertEqual(self.customer.active_subscriptions.count(), 0)

		delta = timezone.timedelta(days=30)
		extended_subscription = subscription.extend(delta)

		self.assertNotEqual(None, extended_subscription.trial_end)
		self.assertTrue(self.customer.has_active_subscription())
		self.assertTrue(self.customer.has_any_active_subscription())

		self.assert_fks(subscription, expected_blank_fks={"djstripe.Customer.coupon"})
Пример #18
0
    def test_upcoming_invoice_with_subscription(
        self,
        invoice_upcoming_mock,
        subscription_retrieve_mock,
        product_retrieve_mock,
        plan_retrieve_mock,
        invoice_retrieve_mock,
        payment_intent_retrieve_mock,
        paymentmethod_card_retrieve_mock,
        charge_retrieve_mock,
        balance_transaction_retrieve_mock,
    ):
        # create invoice for latest_invoice in subscription to work.
        Invoice.sync_from_stripe_data(deepcopy(FAKE_INVOICE))

        invoice = Invoice.upcoming(subscription=Subscription(
            id=FAKE_SUBSCRIPTION["id"]))
        self.assertIsNotNone(invoice)
        self.assertIsNone(invoice.id)
        self.assertIsNone(invoice.save())

        subscription_retrieve_mock.assert_called_once_with(
            api_key=ANY,
            expand=ANY,
            id=FAKE_SUBSCRIPTION["id"],
            stripe_account=None)
        plan_retrieve_mock.assert_not_called()

        self.assertIsNotNone(invoice.plan)
        self.assertEqual(FAKE_PLAN["id"], invoice.plan.id)
Пример #19
0
    def test_cancel_at_period_end(self, customer_retrieve_mock, subscription_retrieve_mock, plan_retrieve_mock):
        current_period_end = timezone.now() + timezone.timedelta(days=7)

        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        subscription.current_period_end = current_period_end
        subscription.save()

        canceled_subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        canceled_subscription_fake["current_period_end"] = datetime_to_unix(current_period_end)
        canceled_subscription_fake["canceled_at"] = datetime_to_unix(timezone.now())
        subscription_retrieve_mock.return_value = canceled_subscription_fake  # retrieve().delete()

        self.assertTrue(self.customer.has_active_subscription())
        self.assertTrue(self.customer.has_any_active_subscription())
        self.assertEqual(self.customer.active_subscriptions.count(), 1)
        self.assertTrue(subscription in self.customer.active_subscriptions)

        new_subscription = subscription.cancel(at_period_end=True)
        self.assertEqual(self.customer.active_subscriptions.count(), 1)
        self.assertTrue(new_subscription in self.customer.active_subscriptions)

        self.assertEqual(SubscriptionStatus.active, new_subscription.status)
        self.assertEqual(True, new_subscription.cancel_at_period_end)
        self.assertNotEqual(new_subscription.canceled_at, new_subscription.ended_at)
        self.assertTrue(new_subscription.is_valid())
        self.assertTrue(self.customer.has_active_subscription())
        self.assertTrue(self.customer.has_any_active_subscription())
Пример #20
0
    def test_sync_from_stripe_data2(self, customer_retrieve_mock,
                                    product_retrieve_mock, plan_retrieve_mock):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION_II)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        self.assert_fks(subscription,
                        expected_blank_fks=self.default_expected_blank_fks)
Пример #21
0
    def test_cancel_during_trial_sets_at_period_end(self,
                                                    customer_retrieve_mock,
                                                    subscription_retrieve_mock,
                                                    plan_retrieve_mock):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        subscription.trial_end = timezone.now() + timezone.timedelta(days=7)
        subscription.save()

        cancel_timestamp = datetime_to_unix(timezone.now())
        canceled_subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        canceled_subscription_fake["status"] = Subscription.STATUS_CANCELED
        canceled_subscription_fake["canceled_at"] = cancel_timestamp
        canceled_subscription_fake["ended_at"] = cancel_timestamp
        subscription_retrieve_mock.return_value = canceled_subscription_fake  # retrieve().delete()

        self.assertTrue(self.customer.has_active_subscription())
        self.assertTrue(self.customer.has_any_active_subscription())

        new_subscription = subscription.cancel(at_period_end=False)

        self.assertEqual(Subscription.STATUS_CANCELED, new_subscription.status)
        self.assertEqual(False, new_subscription.cancel_at_period_end)
        self.assertEqual(new_subscription.canceled_at,
                         new_subscription.ended_at)
        self.assertFalse(new_subscription.is_valid())
        self.assertFalse(self.customer.has_active_subscription())
        self.assertFalse(self.customer.has_any_active_subscription())
Пример #22
0
    def test_cancel_already_canceled(
        self,
        subscription_retrieve_mock,
        product_retrieve_mock,
        subscription_delete_mock,
    ):
        subscription_delete_mock.side_effect = InvalidRequestError(
            "No such subscription: sub_xxxx", "blah")

        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        self.assertEqual(
            Subscription.objects.filter(status="canceled").count(), 0)
        subscription.cancel(at_period_end=False)
        self.assertEqual(
            Subscription.objects.filter(status="canceled").count(), 1)

        self.assert_fks(
            subscription,
            expected_blank_fks={
                "djstripe.Customer.coupon",
                "djstripe.Subscription.pending_setup_intent",
            },
        )
Пример #23
0
    def test_str(self, customer_retrieve_mock, plan_retreive_mock):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        self.assertEqual(
            str(subscription), "{email} on {plan}".format(email=self.user.email, plan=str(subscription.plan))
        )
Пример #24
0
    def test_cancel_at_period_end(self, customer_retrieve_mock,
                                  subscription_retrieve_mock,
                                  plan_retrieve_mock):
        current_period_end = timezone.now() + timezone.timedelta(days=7)

        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        subscription.current_period_end = current_period_end
        subscription.save()

        canceled_subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        canceled_subscription_fake["current_period_end"] = datetime_to_unix(
            current_period_end)
        canceled_subscription_fake["canceled_at"] = datetime_to_unix(
            timezone.now())
        subscription_retrieve_mock.return_value = canceled_subscription_fake  # retrieve().delete()

        self.assertTrue(self.customer.has_active_subscription())
        self.assertTrue(self.customer.has_any_active_subscription())
        self.assertEquals(self.customer.active_subscriptions.count(), 1)
        self.assertTrue(subscription in self.customer.active_subscriptions)

        new_subscription = subscription.cancel(at_period_end=True)
        self.assertEquals(self.customer.active_subscriptions.count(), 1)
        self.assertTrue(new_subscription in self.customer.active_subscriptions)

        self.assertEqual(Subscription.STATUS_ACTIVE, new_subscription.status)
        self.assertEqual(True, new_subscription.cancel_at_period_end)
        self.assertNotEqual(new_subscription.canceled_at,
                            new_subscription.ended_at)
        self.assertTrue(new_subscription.is_valid())
        self.assertTrue(self.customer.has_active_subscription())
        self.assertTrue(self.customer.has_any_active_subscription())
Пример #25
0
    def test_sync_metered_plan(
        self,
        subscription_retrieve_mock,
        customer_retrieve_mock,
        product_retrieve_mock,
        plan_retrieve_mock,
    ):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION_METERED)
        self.assertNotIn(
            "quantity",
            subscription_fake["items"]["data"],
            "Expect Metered plan SubscriptionItem to have no quantity",
        )

        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        items = subscription.items.all()
        self.assertEqual(1, len(items))

        item = items[0]

        self.assertEqual(subscription.quantity, 1)
        # Note that subscription.quantity is 1,
        # but item.quantity isn't set on metered plans
        self.assertIsNone(item.quantity)
        self.assertEqual(item.plan.id, FAKE_PLAN_METERED["id"])

        self.assert_fks(subscription,
                        expected_blank_fks=self.default_expected_blank_fks)
Пример #26
0
    def test_extend_with_trial(
        self,
        customer_retrieve_mock,
        subscription_retrieve_mock,
        product_retrieve_mock,
        plan_retrieve_mock,
    ):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        subscription.trial_end = timezone.now() + timezone.timedelta(days=5)
        subscription.save()

        delta = timezone.timedelta(days=30)
        new_trial_end = subscription.trial_end + delta

        extended_subscription = subscription.extend(delta)

        self.assertEqual(new_trial_end.replace(microsecond=0),
                         extended_subscription.trial_end)
        self.assertTrue(self.customer.has_active_subscription())
        self.assertTrue(self.customer.has_any_active_subscription())

        self.assert_fks(
            subscription,
            expected_blank_fks={
                "djstripe.Customer.coupon",
                "djstripe.Subscription.pending_setup_intent",
            },
        )
Пример #27
0
    def test_update_with_plan_model(
        self,
        customer_retrieve_mock,
        subscription_retrieve_mock,
        subscription_modify_mock,
        product_retrieve_mock,
        plan_retrieve_mock,
    ):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        new_plan = Plan.sync_from_stripe_data(deepcopy(FAKE_PLAN_II))

        self.assertEqual(FAKE_PLAN["id"], subscription.plan.id)

        # Update the Subscription's plan
        subscription_updated = deepcopy(FAKE_SUBSCRIPTION)
        subscription_updated["plan"] = deepcopy(FAKE_PLAN_II)
        subscription_modify_mock.return_value = subscription_updated

        new_subscription = subscription.update(plan=new_plan)

        self.assertEqual(FAKE_PLAN_II["id"], new_subscription.plan.id)

        self.assert_fks(subscription,
                        expected_blank_fks=self.default_expected_blank_fks)

        self.assert_fks(new_plan, expected_blank_fks={})
Пример #28
0
    def test_update_set_empty_value(
        self,
        customer_retrieve_mock,
        subscription_retrieve_mock,
        product_retrieve_mock,
        plan_retrieve_mock,
    ):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription_fake.update({"tax_percent": Decimal(20.0)})
        subscription_retrieve_mock.return_value = subscription_fake
        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        self.assertEqual(Decimal(20.0), subscription.tax_percent)

        new_subscription = subscription.update(tax_percent=Decimal(0.0))

        self.assertEqual(Decimal(0.0), new_subscription.tax_percent)

        self.assert_fks(
            subscription,
            expected_blank_fks={
                "djstripe.Customer.coupon",
                "djstripe.Subscription.pending_setup_intent",
            },
        )
Пример #29
0
    def test_extend(
        self,
        customer_retrieve_mock,
        subscription_retrieve_mock,
        subscription_modify_mock,
        product_retrieve_mock,
        plan_retrieve_mock,
    ):
        current_period_end = timezone.now() - timezone.timedelta(days=20)
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription_fake["current_period_end"] = int(
            current_period_end.timestamp())
        subscription_retrieve_mock.return_value = subscription_fake

        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        self.assertFalse(subscription in self.customer.active_subscriptions)
        self.assertEqual(self.customer.active_subscriptions.count(), 0)

        # Extend the Subscription by 30 days
        delta = timezone.timedelta(days=30)
        subscription_updated = deepcopy(subscription_fake)
        subscription_updated["trial_end"] = int(
            (current_period_end + delta).timestamp())
        subscription_modify_mock.return_value = subscription_updated

        extended_subscription = subscription.extend(delta)
        product = Product.sync_from_stripe_data(deepcopy(FAKE_PRODUCT))

        self.assertNotEqual(None, extended_subscription.trial_end)
        self.assertTrue(self.customer.is_subscribed_to(product))
        self.assertTrue(self.customer.has_any_active_subscription())

        self.assert_fks(subscription,
                        expected_blank_fks=self.default_expected_blank_fks)
Пример #30
0
	def test_cancel_during_trial_sets_at_period_end(
		self,
		customer_retrieve_mock,
		subscription_retrieve_mock,
		product_retrieve_mock,
		plan_retrieve_mock,
	):
		subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		subscription = Subscription.sync_from_stripe_data(subscription_fake)
		subscription.trial_end = timezone.now() + timezone.timedelta(days=7)
		subscription.save()

		cancel_timestamp = datetime_to_unix(timezone.now())
		canceled_subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		canceled_subscription_fake["status"] = SubscriptionStatus.canceled
		canceled_subscription_fake["canceled_at"] = cancel_timestamp
		canceled_subscription_fake["ended_at"] = cancel_timestamp
		subscription_retrieve_mock.return_value = (
			canceled_subscription_fake
		)  # retrieve().delete()

		self.assertTrue(self.customer.has_active_subscription())
		self.assertTrue(self.customer.has_any_active_subscription())

		new_subscription = subscription.cancel(at_period_end=False)

		self.assertEqual(SubscriptionStatus.canceled, new_subscription.status)
		self.assertEqual(False, new_subscription.cancel_at_period_end)
		self.assertEqual(new_subscription.canceled_at, new_subscription.ended_at)
		self.assertFalse(new_subscription.is_valid())
		self.assertFalse(self.customer.has_active_subscription())
		self.assertFalse(self.customer.has_any_active_subscription())

		self.assert_fks(subscription, expected_blank_fks={"djstripe.Customer.coupon"})
Пример #31
0
	def test_cancel_during_trial_sets_at_period_end(
		self, customer_retrieve_mock, subscription_retrieve_mock, plan_retrieve_mock
	):
		subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		subscription = Subscription.sync_from_stripe_data(subscription_fake)
		subscription.trial_end = timezone.now() + timezone.timedelta(days=7)
		subscription.save()

		cancel_timestamp = datetime_to_unix(timezone.now())
		canceled_subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		canceled_subscription_fake["status"] = SubscriptionStatus.canceled
		canceled_subscription_fake["canceled_at"] = cancel_timestamp
		canceled_subscription_fake["ended_at"] = cancel_timestamp
		subscription_retrieve_mock.return_value = (
			canceled_subscription_fake
		)  # retrieve().delete()

		self.assertTrue(self.customer.has_active_subscription())
		self.assertTrue(self.customer.has_any_active_subscription())

		new_subscription = subscription.cancel(at_period_end=False)

		self.assertEqual(SubscriptionStatus.canceled, new_subscription.status)
		self.assertEqual(False, new_subscription.cancel_at_period_end)
		self.assertEqual(new_subscription.canceled_at, new_subscription.ended_at)
		self.assertFalse(new_subscription.is_valid())
		self.assertFalse(self.customer.has_active_subscription())
		self.assertFalse(self.customer.has_any_active_subscription())

		self.assert_fks(
			subscription,
			expected_blank_fks={"djstripe.Customer.coupon", "djstripe.Plan.product"},
		)
Пример #32
0
    def test_update_with_plan_model(
        self,
        customer_retrieve_mock,
        subscription_retrieve_mock,
        product_retrieve_mock,
        plan_retrieve_mock,
    ):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        new_plan = Plan.sync_from_stripe_data(deepcopy(FAKE_PLAN_II))

        self.assertEqual(FAKE_PLAN["id"], subscription.plan.id)

        new_subscription = subscription.update(plan=new_plan)

        self.assertEqual(FAKE_PLAN_II["id"], new_subscription.plan.id)

        self.assert_fks(
            subscription,
            expected_blank_fks={
                "djstripe.Customer.coupon",
                "djstripe.Subscription.pending_setup_intent",
            },
        )

        self.assert_fks(new_plan, expected_blank_fks={})
Пример #33
0
	def test_sync_metered_plan(
		self,
		subscription_retrieve_mock,
		customer_retrieve_mock,
		product_retrieve_mock,
		plan_retrieve_mock,
	):
		subscription_fake = deepcopy(FAKE_SUBSCRIPTION_METERED)
		self.assertNotIn(
			"quantity",
			subscription_fake["items"]["data"],
			"Expect Metered plan SubscriptionItem to have no quantity",
		)

		subscription = Subscription.sync_from_stripe_data(subscription_fake)

		items = subscription.items.all()
		self.assertEqual(1, len(items))

		item = items[0]

		self.assertEqual(subscription.quantity, 1)
		# Note that subscription.quantity is 1, but item.quantity isn't set on metered plans,
		# it probably should be nullable
		self.assertEqual(item.quantity, 0)
		self.assertEqual(item.plan.id, FAKE_PLAN_METERED["id"])

		self.assert_fks(subscription, expected_blank_fks={"djstripe.Customer.coupon"})
Пример #34
0
	def test_extend(
		self, customer_retrieve_mock, subscription_retrieve_mock, plan_retrieve_mock
	):
		subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		subscription_fake["current_period_end"] = datetime_to_unix(
			timezone.now() - timezone.timedelta(days=20)
		)

		subscription_retrieve_mock.return_value = subscription_fake

		subscription = Subscription.sync_from_stripe_data(subscription_fake)
		self.assertFalse(subscription in self.customer.active_subscriptions)
		self.assertEqual(self.customer.active_subscriptions.count(), 0)

		delta = timezone.timedelta(days=30)
		extended_subscription = subscription.extend(delta)

		self.assertNotEqual(None, extended_subscription.trial_end)
		self.assertTrue(self.customer.has_active_subscription())
		self.assertTrue(self.customer.has_any_active_subscription())

		self.assert_fks(
			subscription,
			expected_blank_fks={"djstripe.Customer.coupon", "djstripe.Plan.product"},
		)
Пример #35
0
    def test_extend_with_trial(
        self,
        customer_retrieve_mock,
        subscription_retrieve_mock,
        product_retrieve_mock,
        plan_retrieve_mock,
    ):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        subscription.trial_end = timezone.now() + timezone.timedelta(days=5)
        subscription.save()

        delta = timezone.timedelta(days=30)
        new_trial_end = subscription.trial_end + delta

        extended_subscription = subscription.extend(delta)

        self.assertEqual(new_trial_end.replace(microsecond=0),
                         extended_subscription.trial_end)
        self.assertTrue(self.customer.has_active_subscription())
        self.assertTrue(self.customer.is_subscribed_to(FAKE_PRODUCT["id"]))
        self.assertTrue(self.customer.has_any_active_subscription())

        self.assert_fks(subscription,
                        expected_blank_fks=self.default_expected_blank_fks)
Пример #36
0
    def test_is_status_temporarily_current(self, customer_retrieve_mock,
                                           product_retrieve_mock,
                                           plan_retrieve_mock):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        subscription.canceled_at = timezone.now() + timezone.timedelta(days=7)
        subscription.current_period_end = timezone.now() + timezone.timedelta(
            days=7)
        subscription.cancel_at_period_end = True
        subscription.save()

        self.assertTrue(subscription.is_status_current())
        self.assertTrue(subscription.is_status_temporarily_current())
        self.assertTrue(subscription.is_valid())
        self.assertTrue(subscription in self.customer.active_subscriptions)
        self.assertTrue(self.customer.has_active_subscription())
        self.assertTrue(self.customer.has_any_active_subscription())

        self.assert_fks(
            subscription,
            expected_blank_fks={
                "djstripe.Customer.coupon",
                "djstripe.Subscription.pending_setup_intent",
            },
        )
Пример #37
0
    def test_sync_multi_plan(
        self,
        subscription_retrieve_mock,
        customer_retrieve_mock,
        product_retrieve_mock,
        plan_retrieve_mock,
    ):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION_MULTI_PLAN)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        self.assertIsNone(subscription.plan)
        self.assertIsNone(subscription.quantity)

        items = subscription.items.all()
        self.assertEqual(2, len(items))

        self.assert_fks(
            subscription,
            expected_blank_fks={
                "djstripe.Customer.coupon",
                "djstripe.Customer.subscriber",
                "djstripe.Subscription.plan",
                "djstripe.Subscription.pending_setup_intent",
            },
        )
Пример #38
0
    def test_user_has_active_subscription(self):
        subscription = Subscription.sync_from_stripe_data(deepcopy(FAKE_SUBSCRIPTION))
        subscription.current_period_end = timezone.now() + timezone.timedelta(days=10)
        subscription.save()

        # Assert that the customer's subscription is valid
        self.assertTrue(subscriber_has_active_subscription(self.user))
Пример #39
0
    def test_cancel_error_in_cancel(self, subscription_delete_mock):
        subscription_delete_mock.side_effect = InvalidRequestError("Unexpected error", "blah")

        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        with self.assertRaises(InvalidRequestError):
            subscription.cancel()
Пример #40
0
    def test_str(self, customer_retrieve_mock, plan_retreive_mock):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        self.assertEqual(
            str(subscription),
            "{email} on {plan}".format(email=self.user.email,
                                       plan=str(subscription.plan)))
Пример #41
0
 def setUp(self):
     self.settings(ROOT_URLCONF=self.urlconf)
     self.factory = RequestFactory()
     self.user = get_user_model().objects.create_user(username="******", email="*****@*****.**")
     self.customer = Customer.sync_from_stripe_data(FAKE_CUSTOMER)
     self.customer.subscriber = self.user
     self.customer.save()
     self.subscription = Subscription.sync_from_stripe_data(FAKE_SUBSCRIPTION)
     self.middleware = SubscriptionPaymentMiddleware()
Пример #42
0
    def test_update(self, customer_retrieve_mock, subscription_retrieve_mock, plan_retrieve_mock):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        self.assertEqual(1, subscription.quantity)

        new_subscription = subscription.update(quantity=4)

        self.assertEqual(4, new_subscription.quantity)
Пример #43
0
    def test_cancel_already_canceled(self, subscription_retrieve_mock, subscription_delete_mock):
        subscription_delete_mock.side_effect = InvalidRequestError("No such subscription: sub_xxxx", "blah")

        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        self.assertEqual(Subscription.objects.filter(status="canceled").count(), 0)
        subscription.cancel()
        self.assertEqual(Subscription.objects.filter(status="canceled").count(), 1)
Пример #44
0
    def test_extend_negative_delta(self, customer_retrieve_mock, subscription_retrieve_mock, plan_retrieve_mock):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        with self.assertRaises(ValueError):
            subscription.extend(timezone.timedelta(days=-30))

        self.assertFalse(self.customer.has_active_subscription())
        self.assertFalse(self.customer.has_any_active_subscription())
Пример #45
0
	def test_cancel_error_in_cancel(self, product_retrieve_mock, subscription_delete_mock):
		subscription_delete_mock.side_effect = InvalidRequestError("Unexpected error", "blah")

		subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		subscription = Subscription.sync_from_stripe_data(subscription_fake)

		with self.assertRaises(InvalidRequestError):
			subscription.cancel(at_period_end=False)

		self.assert_fks(subscription, expected_blank_fks={"djstripe.Customer.coupon"})
Пример #46
0
    def test_update_with_plan_model(self, customer_retrieve_mock, subscription_retrieve_mock, plan_retrieve_mock):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        new_plan = Plan.sync_from_stripe_data(deepcopy(FAKE_PLAN_II))

        self.assertEqual(FAKE_PLAN["id"], subscription.plan.stripe_id)

        new_subscription = subscription.update(plan=new_plan)

        self.assertEqual(FAKE_PLAN_II["id"], new_subscription.plan.stripe_id)
Пример #47
0
	def test_str(self, customer_retrieve_mock, product_retrieve_mock, plan_retrieve_mock):
		subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		subscription = Subscription.sync_from_stripe_data(subscription_fake)

		self.assertEqual(
			str(subscription),
			"{email} on {plan}".format(email=self.user.email, plan=str(subscription.plan)),
		)

		self.assert_fks(subscription, expected_blank_fks={"djstripe.Customer.coupon"})
Пример #48
0
    def test_update_set_empty_value(self, customer_retrieve_mock, subscription_retrieve_mock, plan_retrieve_mock):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription_fake.update({'tax_percent': Decimal(20.0)})
        subscription_retrieve_mock.return_value = subscription_fake
        subscription = Subscription.sync_from_stripe_data(subscription_fake)

        self.assertEqual(Decimal(20.0), subscription.tax_percent)

        new_subscription = subscription.update(tax_percent=Decimal(0.0))

        self.assertEqual(Decimal(0.0), new_subscription.tax_percent)
Пример #49
0
    def test_is_status_temporarily_current_false(self, customer_retrieve_mock, plan_retreive_mock):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        subscription.current_period_end = timezone.now() + timezone.timedelta(days=7)
        subscription.save()

        self.assertTrue(subscription.is_status_current())
        self.assertFalse(subscription.is_status_temporarily_current())
        self.assertTrue(subscription.is_valid())
        self.assertTrue(subscription in self.customer.active_subscriptions)
        self.assertTrue(self.customer.has_active_subscription())
        self.assertTrue(self.customer.has_any_active_subscription())
Пример #50
0
    def test_get_subscription(self):
        """Test a GET to the SubscriptionRestView.

        Should return the correct data.
        """
        plan = Plan.sync_from_stripe_data(deepcopy(FAKE_PLAN))
        subscription = Subscription.sync_from_stripe_data(deepcopy(FAKE_SUBSCRIPTION))

        response = self.client.get(self.url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data["plan"], plan.id)
        self.assertEqual(response.data['status'], subscription.status)
        self.assertEqual(response.data['cancel_at_period_end'], subscription.cancel_at_period_end)
Пример #51
0
	def test_user_active_subscription(self, product_retrieve_mock, plan_retrieve_mock):
		user = get_user_model().objects.create_user(
			username="******", email="*****@*****.**"
		)
		FAKE_CUSTOMER.create_for_user(user)
		subscription = Subscription.sync_from_stripe_data(deepcopy(FAKE_SUBSCRIPTION))
		subscription.current_period_end = FUTURE_DATE
		subscription.save()

		request = self.factory.get("/account/")
		request.user = user

		response = self.test_view(request)
		self.assertEqual(response.status_code, 200)
Пример #52
0
    def test_extend_with_trial(self, customer_retrieve_mock, subscription_retrieve_mock, plan_retrieve_mock):
        subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
        subscription = Subscription.sync_from_stripe_data(subscription_fake)
        subscription.trial_end = timezone.now() + timezone.timedelta(days=5)
        subscription.save()

        delta = timezone.timedelta(days=30)
        new_trial_end = subscription.trial_end + delta

        extended_subscription = subscription.extend(delta)

        self.assertEqual(new_trial_end.replace(microsecond=0), extended_subscription.trial_end)
        self.assertTrue(self.customer.has_active_subscription())
        self.assertTrue(self.customer.has_any_active_subscription())
Пример #53
0
	def test_cancel_already_canceled(
		self, subscription_retrieve_mock, product_retrieve_mock, subscription_delete_mock
	):
		subscription_delete_mock.side_effect = InvalidRequestError(
			"No such subscription: sub_xxxx", "blah"
		)

		subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		subscription = Subscription.sync_from_stripe_data(subscription_fake)

		self.assertEqual(Subscription.objects.filter(status="canceled").count(), 0)
		subscription.cancel(at_period_end=False)
		self.assertEqual(Subscription.objects.filter(status="canceled").count(), 1)

		self.assert_fks(subscription, expected_blank_fks={"djstripe.Customer.coupon"})
Пример #54
0
	def setUp(self):
		self.settings(ROOT_URLCONF=self.urlconf)
		self.factory = RequestFactory()
		self.user = get_user_model().objects.create_user(
			username="******", email="*****@*****.**"
		)
		self.customer = Customer.sync_from_stripe_data(FAKE_CUSTOMER)
		self.customer.subscriber = self.user
		self.customer.save()

		with patch(
			"stripe.Product.retrieve", return_value=deepcopy(FAKE_PRODUCT), autospec=True
		):
			self.subscription = Subscription.sync_from_stripe_data(FAKE_SUBSCRIPTION)

		self.middleware = SubscriptionPaymentMiddleware()
Пример #55
0
	def test_update(
		self,
		customer_retrieve_mock,
		subscription_retrieve_mock,
		product_retrieve_mock,
		plan_retrieve_mock,
	):
		subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		subscription = Subscription.sync_from_stripe_data(subscription_fake)

		self.assertEqual(1, subscription.quantity)

		new_subscription = subscription.update(quantity=4)

		self.assertEqual(4, new_subscription.quantity)

		self.assert_fks(subscription, expected_blank_fks={"djstripe.Customer.coupon"})
Пример #56
0
	def test_is_status_temporarily_current_false_and_cancelled(
		self, customer_retrieve_mock, product_retrieve_mock, plan_retrieve_mock
	):
		subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		subscription = Subscription.sync_from_stripe_data(subscription_fake)
		subscription.status = SubscriptionStatus.canceled
		subscription.current_period_end = timezone.now() + timezone.timedelta(days=7)
		subscription.save()

		self.assertFalse(subscription.is_status_current())
		self.assertFalse(subscription.is_status_temporarily_current())
		self.assertFalse(subscription.is_valid())
		self.assertFalse(subscription in self.customer.active_subscriptions)
		self.assertFalse(self.customer.has_active_subscription())
		self.assertFalse(self.customer.has_any_active_subscription())

		self.assert_fks(subscription, expected_blank_fks={"djstripe.Customer.coupon"})
Пример #57
0
	def test_get_subscription(self):
		"""Test a GET to the SubscriptionRestView.

		Should return the correct data.
		"""
		with patch(
			"stripe.Product.retrieve", return_value=deepcopy(FAKE_PRODUCT), autospec=True
		):
			plan = Plan.sync_from_stripe_data(deepcopy(FAKE_PLAN))
		subscription = Subscription.sync_from_stripe_data(deepcopy(FAKE_SUBSCRIPTION))

		response = self.client.get(self.url)
		self.assertEqual(response.status_code, status.HTTP_200_OK)
		self.assertEqual(response.data["plan"], plan.djstripe_id)
		self.assertEqual(response.data["status"], subscription.status)
		self.assertEqual(
			response.data["cancel_at_period_end"], subscription.cancel_at_period_end
		)
Пример #58
0
	def test_update_set_empty_value(
		self,
		customer_retrieve_mock,
		subscription_retrieve_mock,
		product_retrieve_mock,
		plan_retrieve_mock,
	):
		subscription_fake = deepcopy(FAKE_SUBSCRIPTION)
		subscription_fake.update({"tax_percent": Decimal(20.0)})
		subscription_retrieve_mock.return_value = subscription_fake
		subscription = Subscription.sync_from_stripe_data(subscription_fake)

		self.assertEqual(Decimal(20.0), subscription.tax_percent)

		new_subscription = subscription.update(tax_percent=Decimal(0.0))

		self.assertEqual(Decimal(0.0), new_subscription.tax_percent)

		self.assert_fks(subscription, expected_blank_fks={"djstripe.Customer.coupon"})