def test_user_subscribed_is_run_when_user_tier_is_changed_to_paid( self, user_subscribed, session): free_user = UserFactory(tier="free") free_user.plan = Plan.paid() session.add(free_user) session.commit() user_subscribed.assert_called_with(free_user.id, Plan.paid().id)
def test_after_commit_hooks_are_specific_to_a_session( self, user_subscribed, session, app): # What does this test prove? Well - we start by showing # the thing works and by setting up a an "after_commit" hook # on the session. (There SHOULD BE one session per request.) # The next request should NOT fire the "after_commit" hook # because it has a new session. IE - we are not leaking # Model instances across requests, and not firing subscribe # events for instances we didn't change free_user = UserFactory(tier="free") free_user.plan = Plan.paid() session.add(free_user) session.commit() session.expire_all() user_subscribed.assert_called_with(free_user.id, Plan.paid().id) user_subscribed.reset_mock() sess = db.create_scoped_session() free_user2 = UserFactory(tier="free", email="*****@*****.**") session.expunge(free_user2.plan) sess.add(free_user2) sess.commit() user_subscribed.assert_not_called() sess.remove()
def test_user_unlink_from_plan_via_subscription(self): """Unlink a User from a plan based on change in their stripe subscription""" user = StripedUserFactory(tier="paid", stripe__payment_method="pm_card_visa") subscription = UserStripe(user)._retrieve_users_subscriptions( Plan.paid()) UserStripe(user).unlink_from_plan_via_subscription(subscription.id) assert UserStripe(user)._retrieve_users_subscriptions( Plan.paid()) is None assert user.plan == Plan.free()
def test_user_subscribed_is_run_when_user_tier_is_changed_to_paid( self, user_subscribed, session ): free_user = UserFactory(tier="free") UserUpdate( user=free_user, rels={"plan": {"data": {"type": "plan", "id": str(Plan.paid().id)}}}, ).update() db.session.commit() user_subscribed.assert_called_with(free_user.id, Plan.paid().id)
def test_locate(): """ Convert a Json-API style locator ref to a python object """ p = Plan.paid() obj = locate({"type": "plan", "id": str(p.id)}) assert obj == p
def test_user_link_to_plan_via_subscription(self): """Link a User to a Plan based on a change in their stripe subscription""" user = StripedUserFactory( tier="paid", stripe__payment_method="pm_card_threeDSecure2Required") subscriptions = stripe.Subscription.list(plan=Plan.paid().stripe_id, customer=user.stripe_id) # this subscription is _NOT_ actually paid now, but we check in the event # listener - this method just makes sure the User's plan reflects the # subscription they'r paying for UserStripe(user).link_to_plan_via_subscription( subscriptions.data[0].id) assert user.plan == Plan.paid()
def test_striped_user_can_modify_plan(self, app, session): """ A user with a valid stripe_id is able to change their payment method """ app.test_client_class = TestClient user = StripedUserFactory(tier="free", stripe__payment_method="pm_card_visa") session.add(user) session.flush() plan_id = Plan.paid().id with app.test_client(user=user) as client: res = client.patch( "/account", json={ "data": { "type": "user", "attributes": {}, "relationships": { "plan": {"data": {"type": "plan", "id": str(plan_id)}} }, } }, ) assert res.status_code == 200 user = User.query.filter_by(uuid=user.uuid).first() assert user.tier == "paid"
def test_user_async_unsubscribe(self, unlink_from_plan, session): user = UserFactory(tier="free", stripe_id="cust_12345") session.add(user) session.flush() plan = Plan.paid() user_unsubscribed(user.id, plan.id) assert unlink_from_plan.called_once_with(user, plan)
def test_user_fails_to_subscribe_no_card(self, _sf, _ss, _sfa, session): """ User couldn't subscribe because they didn't setup a card or stripe account""" user = UnstripedUserFactory() plan = Plan.paid() uss = UserStripe(user) session.add(user) session.flush() with pytest.raises(AssertionError): uss.link_to_plan(plan)
def test_user_can_change_relationship(self, session): free_user = UserFactory(tier="free") plan = Plan.paid() session.add(free_user) session.flush() user = UserUpdate( user=free_user, rels={"plan": {"data": {"type": "plan", "id": str(plan.id)}}}, ).update() assert user.plan == plan
def test_user_unsubscribed(self, unsubscribe_successful, unsubscribe_not_required, session): """ User unsubscribes successfully """ user = SubscribedUserFactory(tier="paid", stripe__payment_method="pm_card_visa") user.plan = Plan.free() session.add(user) session.flush() UserStripe(user).unlink_from_plan(Plan.paid()) assert unsubscribe_successful.called_once assert not unsubscribe_not_required.called
def test_user_unsubscribed_is_run_when_user_tier_is_changed_to_free( self, user_unsubscribed, session ): user = UserFactory() db.session.add(user) db.session.flush() UserUpdate( user=user, rels={"plan": {"data": {"type": "plan", "id": str(Plan.free().id)}}}, ).update() db.session.commit() user_unsubscribed.assert_called_with(user.id, Plan.paid().id)
def test_user_unsubscribed_but_didnt_need_to(self, unsubscribe_successful, unsubscribe_not_required, session): """User can't unsubscribe if they're not subscribed in the first place <taps forehead>""" user = StripedUserFactory(tier="free", stripe__payment_method="pm_card_visa") user.plan = Plan.free() session.add(user) session.flush() UserStripe(user).unlink_from_plan(Plan.paid()) assert not unsubscribe_successful.called assert unsubscribe_not_required.called_once
def test_delete_customer(self, app): """ Delete a Stripe Customer """ user = StripedUserFactory(tier="paid", email="*****@*****.**", stripe__payment_method="pm_card_visa") uss = UserStripe(user) uss.link_to_plan(Plan.paid()) customer_id = user.stripe_id UserStripe(user).delete_stripe_customer() cus = stripe.Customer.retrieve(customer_id) assert cus.deleted is True assert user.plan == Plan.free()
def test_user_subscribed_successfully( self, subscribed_successfully, subscribed_failed, subscription_requires_action, session, ): """ User subscribed sucessfully """ user = StripedUserFactory(tier="paid", stripe__payment_method="pm_card_visa") session.add(user) session.flush() # the user is a paid user when it is submitted to this job # immediately after a commit which changes it's plan_id # NOTE: this test does not actually change the user's plan UserStripe(user).link_to_plan(user.plan) assert not subscribed_failed.called assert not subscription_requires_action.called assert subscribed_successfully.called_once assert user.plan == Plan.paid()
def test_unstriped_user_cannot_modify_plan(self, app, session): """ The user can update plan id only if paymenet method and customer id are set. They cannot be set in the same request.""" app.test_client_class = TestClient user = UnstripedUserFactory() session.add(user) session.flush() plan_id = Plan.paid().id with app.test_client(user=user) as client: res = client.patch( "/account", json={ "data": { "type": "user", "relationships": { "plan": {"data": {"type": "plan", "id": str(plan_id)}} }, } }, ) assert res.status_code == 422