def seat_feature(self): return MeteredFeatureFactory( name="Charcoal Users", unit="Seats", included_units=Decimal('0.00'), product_code=ProductCodeFactory(value="charc-seats"), price_per_unit=Decimal('0.0'))
def metered_feature(self): return MeteredFeatureFactory( name="Charcoal Base Units", unit="Barrels (per seat)", included_units=Decimal('0.00'), included_units_during_trial=Decimal('0.00'), product_code=ProductCodeFactory(value="charc-base"), price_per_unit=Decimal('5.00'), )
def test_subscription_transaction_declined_suspend(self): """ Confirm that a failed transaction can trigger a subscription to suspend. """ # We'll create a plan that starts here start_date = dt.date(2019, 1, 1) # And the trial date ends here too trial_end_date = dt.date(2019, 1, 1) # The customer will use some metered features here metered_usage_on = dt.date(2019, 1, 10) # Docs will be generated to bill here. prev_billing_date = dt.date(2019, 1, 3) # So, the customer grace period ends here. # First billing interval: dt.date(2019, 2, 1) # billing_grace_exp = dt.date(2019, 2, 3) # The next billing check should discover that the subscription # is unpaid. # Billing due date is: dt.date(2019, 2, 6) # With the grace period: dt.date(2019, 2, 9) # billing_post_grace_check = dt.date(2019, 2, 10) # Create a customer # customer = CustomerFactory.create(sales_tax_percent=Decimal('0.00'), payment_due_days=3) PaymentMethodFactory.create( payment_processor=triggered_processor, customer=customer, canceled=False, verified=True, ) # Create a metered feature # mf_price = Decimal('2.5') metered_feature = MeteredFeatureFactory( included_units_during_trial=Decimal('0.00'), price_per_unit=mf_price) currency = 'USD' # Crate a plan with metered features. Generate the invoice after # the 5 day trial period, the plan will be billed every 30 days. # generate_after = 5 plan = PlanFactory.create(interval=Plan.INTERVALS.DAY, interval_count=30, generate_after=generate_after, enabled=True, amount=Decimal('20.00'), trial_period_days=1, metered_features=[metered_feature], currency=currency) # Subscribe the customer # subscription = SubscriptionFactory.create(plan=plan, start_date=start_date, customer=customer) subscription.activate() subscription.save() # Log some metered usage consumed_1 = Decimal('5.00') consumed_2 = Decimal('5.00') mf_log = MeteredFeatureUnitsLogFactory.create( subscription=subscription, metered_feature=metered_feature, start_date=metered_usage_on, end_date=subscription.trial_end, consumed_units=consumed_1) # Generate the docs call_command('generate_docs', billing_date=prev_billing_date, stdout=self.output) proforma = Proforma.objects.first() assert proforma.proforma_entries.count() != 0 assert Subscription.objects.all().count() == 1 assert Invoice.objects.all().count() == 0 assert Proforma.objects.all()[0].total > Decimal('0.00') # Consume more units mf_log.consumed_units += consumed_2 mf_log.save() call_command('generate_docs', billing_date=billing_grace_exp, stdout=self.output) assert Proforma.objects.all().count() != 0 assert Invoice.objects.all().count() == 0 for pf in Proforma.objects.all(): # # Issue the proforma to generate transactions # proforma = Proforma.objects.all()[1] pf.issue() pf.save() self.assertEqual(pf.state, Proforma.STATES.ISSUED) # Fail the transaction for tx in pf.transactions: # tx = proforma.transactions[0] tx.fail() tx.save() self.assertEqual(tx.state, Transaction.States.Failed) assert Transaction.objects.all().count() != 0 call_command('check_subscriptions', billing_date=billing_post_grace_check, stdout=self.output) subscr = Subscription.objects.first() # Scan for subscriptions with unpaid documents logging.debug("subscr %s" % subscr) self.assertEqual(subscr.state, Subscription.STATES.CANCELED)