def test_signin_limit(self): self.plan1.signin_limit = 2 user = Membership(first_name="Testy", last_name="Testerson", email="*****@*****.**", plan="plan1") user.put() # We should have all 2 signins left. self.assertEqual(2, Plan.signins_remaining(user)) # Signin once. user.signins = 1 user.put() self.assertEqual(1, Plan.signins_remaining(user)) # Signin again. user.signins = 2 user.put() self.assertEqual(0, Plan.signins_remaining(user)) # Should never be less than zero. user.signins = 3 user.put() self.assertEqual(0, Plan.signins_remaining(user)) # Give ourselves unlimited signins! self.plan1.signin_limit = None self.assertEqual(None, Plan.signins_remaining(user))
def get_athlete_plan(): p = Plan(current_user.athlete_id) return Response(dumps(p.get_plan()), mimetype='application/json', headers={ 'cache-control': 'max-age=60' })
def test_bad_plan(self): # If we give it a nonexistent plan, it should ignore it. query = urllib.urlencode({"plan": "badplan"}) response = self.test_app.get("/?" + query) self.assertEqual(200, response.status_int) self.assertIn("value=\"choose\"", response.body) # If we give it a plan that is not available, it should show us an error. unavailable_plan = Plan("test_plan", 1, 100, "A test plan.", admin_only=True) query = urllib.urlencode({"plan": unavailable_plan.name}) response = self.test_app.get("/?" + query, expect_errors=True) self.assertEqual(422, response.status_int) self.assertIn(unavailable_plan.name, response.body) self.assertIn("is not available", response.body) # If we're logged in as an admin, though, it should let us. self.testbed.setup_env(user_email=self._TEST_PARAMS["email"], user_is_admin="1", overwrite=True) query = urllib.urlencode({"plan": unavailable_plan.name}) response = self.test_app.get("/?" + query) self.assertEqual(200, response.status_int)
def get(self): user = users.get_current_user() if not user: self.redirect(users.create_login_url(self.request.uri)) return member = Membership.get_by_email(user.email()) if not member: # User is not (yet) a member. self.redirect("/") return else: # Open billing information. url = member.spreedly_url() plan = Plan.get_by_name(member.plan) if plan.legacy: # Show the legacy plan warning. current = plan.get_legacy_pair() self.response.out.write( self.render("templates/billing_popup.html", url=url, legacy=plan, current=current)) return else: self.redirect(url) return
def setUp(self): # Set up testing for application. self.test_app = webtest.TestApp(user_api.app) # Set up datastore for testing. self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() # Create a new plan for testing. Plan.all_plans = [] self.test_plan = Plan("test", 1, 100, "A test plan.", signin_limit=Config().LITE_VISITS) # Add a user to the datastore. self.user = Membership(first_name="Daniel", last_name="Petti", email="*****@*****.**", plan="test", username="******", status="active") self.user.put()
def get(self): user = users.get_current_user() if not user: self.redirect(users.create_login_url(self.request.uri)) return member = Membership.get_by_email(user.email()) if not member: # User is not (yet) a member. self.redirect("/") return else: # Open billing information. url = member.spreedly_url() plan = Plan.get_by_name(member.plan) if plan.legacy: # Show the legacy plan warning. current = plan.get_legacy_pair() self.response.out.write(self.render( "templates/billing_popup.html", url=url, legacy=plan, current=current)) return else: self.redirect(url) return
def setUp(self): super(PlanSelectionTestBase, self).setUp() # Clear all the real plans. Plan.all_plans = [] # Make a couple of plans to test with. self.plan1 = Plan("plan1", 101, "", human_name="First Plan") self.plan2 = Plan("plan2", 102, "", human_name="Second Plan") self.plan3 = Plan("plan3", 103, "", selectable=False, human_name="Third Plan") # Will always be full. self.plan4 = Plan("plan4", 104, "", member_limit=0, human_name="Fourth Plan")
def test_rollover(self): self.user.signins = Config().LITE_VISITS - 2 self.user.status = "active" self.user.put() response = self.test_app.get("/cron/reset_signins") self.assertEqual(200, response.status_int) user = Membership.get_by_email("*****@*****.**") self.assertEqual(-2, user.signins) self.assertEqual("active", user.status) # Test that signins_remaining gives us the right number. test_plan = Plan("test_lite", 1, 100, "A test plan", signin_limit=Config().LITE_VISITS) user.plan = "test_lite" remaining = Plan.signins_remaining(user) self.assertEqual(Config().LITE_VISITS + 2, remaining)
def get(self): user = users.get_current_user() member = Membership.get_by_email(user.email()) if not member: # User is not (yet) a member. self.redirect("/") else: # Open billing information. url = member.spreedly_url() plan = Plan.get_by_name(member.plan) if plan.legacy: self.response.out.write(self.render( "templates/billing_popup.html", url=url)) else: self.redirect(url)
def test_can_subscribe(self): self.assertTrue(Plan.can_subscribe("plan1")) self.assertTrue(Plan.can_subscribe("plan2")) self.assertFalse(Plan.can_subscribe("plan3")) self.assertFalse(Plan.can_subscribe("plan4")) self.assertFalse(Plan.can_subscribe("plan5")) # Test that it lets us sign up for plan 5 if we are an admin. self.testbed.setup_env(user_is_admin="1") self.assertTrue(Plan.can_subscribe("plan5"))
def test_rollover(self): self.user.signins = Config().LITE_VISITS - 2 self.user.status = "active" self.user.put() response = self.test_app.get("/cron/reset_signins") self.assertEqual(200, response.status_int) user = Membership.get_by_email("*****@*****.**") self.assertEqual(-2, user.signins) self.assertEqual("active", user.status) # Test that signins_remaining gives us the right number. test_plan = Plan("test_lite", 1, 100, "A test plan", signin_limit = Config().LITE_VISITS) user.plan = "test_lite" remaining = Plan.signins_remaining(user) self.assertEqual(Config().LITE_VISITS + 2, remaining)
def test_skip_if_account(self): plan = Plan("test", 0, 100, "This is a test plan.") existing_user = Membership(first_name=self._TEST_PARAMS["first_name"], last_name=self._TEST_PARAMS["last_name"], email=self._TEST_PARAMS["email"], spreedly_token=None, username="******", password="******", plan=plan.name) existing_user.put() response = self.test_app.post("/", self._TEST_PARAMS) self.assertEqual(302, response.status_int) self.assertIn("subs.pinpayments.com", response.location) self.assertIn(plan.plan_id, response.location) self.assertIn(existing_user.username, response.location) self.assertNotIn(existing_user.password, response.location)
def setUp(self): # Create and activate testbed instance. self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() # Clear all the real plans. Plan.all_plans = [] Plan.legacy_pairs.clear() # Make some test plans. self.plan1 = Plan("plan1", 1, 25, "Test plan 1") self.plan2 = Plan("plan2", 2, 50, "Test plan 2", selectable=False) self.plan3 = Plan("plan3", 3, 100, "Test plan 3", full=True) self.plan4 = Plan("plan4", 4, 75, "Test plan 4", legacy=self.plan1) self.plan5 = Plan("plan5", 5, 100, "Test plan 5", admin_only=True)
def setUp(self): super(AccountHandlerBase, self).setUp() # Start by putting a user in the datastore. user = Membership(first_name="Testy", last_name="Testerson", email="*****@*****.**", plan=None, status=None, hash="anunlikelyhash") user.put() self.user_hash = user.hash # Add the plans we need. Plan.all_plans = [] Plan.legacy_pairs = set() self.test_plan = Plan("test", 0, 100, "A test plan.") # Clear fake usernames between tests. ProjectHandler.clear_usernames()
def setUp(self): # Create and activate testbed instance. self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() # Clear all the real plans. Plan.all_plans = [] Plan.legacy_pairs.clear() # Make some test plans. self.plan1 = Plan("plan1", 25, "Test plan 1") self.plan2 = Plan("plan2", 50, "Test plan 2", selectable=False) self.plan3 = Plan("plan3", 100, "Test plan 3", full=True) self.plan4 = Plan("plan4", 75, "Test plan 4", legacy=self.plan1) self.plan5 = Plan("plan5", 100, "Test plan 5", admin_only=True)
def test_selection_page(self): active, hidden = Plan.get_plans_to_show() self.assertEqual([self.plan1], active) self.assertEqual([self.plan3], hidden)
def test_get_all_plan_ids(self): ids = Plan.get_all_plan_ids() self.assertEqual([("plan1", "plan1"), ("plan2", "plan2"), ("plan3", "plan3"), ("plan4", "plan4"), ("plan5", "plan5")], ids)
def test_aliases(self): self.plan1.aliases = ["alias"] plan1 = Plan.get_by_name("alias") self.assertEqual(self.plan1, plan1)
class PlanTests(unittest.TestCase): """ Set up for every test. """ def setUp(self): # Create and activate testbed instance. self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() # Clear all the real plans. Plan.all_plans = [] Plan.legacy_pairs.clear() # Make some test plans. self.plan1 = Plan("plan1", 25, "Test plan 1") self.plan2 = Plan("plan2", 50, "Test plan 2", selectable=False) self.plan3 = Plan("plan3", 100, "Test plan 3", full=True) self.plan4 = Plan("plan4", 75, "Test plan 4", legacy=self.plan1) self.plan5 = Plan("plan5", 100, "Test plan 5", admin_only=True) """ Cleanup for every test. """ def tearDown(self): self.testbed.deactivate() """ Tests that we can get a list of plans to display on the plan selection page. """ def test_selection_page(self): active, hidden = Plan.get_plans_to_show() self.assertEqual([self.plan1], active) self.assertEqual([self.plan3], hidden) """ Tests that setting a member limit works. """ def test_member_limit(self): self.plan1.member_limit = 2 # Put some people in the datastore. user1 = Membership(first_name="Testy1", last_name="Testerson", email="*****@*****.**", plan="plan1") user2 = Membership(first_name="Testy2", last_name="Testerson", email="*****@*****.**", plan="plan1") # The plan should not be full initially. self.assertFalse(self.plan1.is_full()) # Adding one user should still not make it full. user1.put() self.assertFalse(self.plan1.is_full()) # Adding the other user should make it full. user2.put() self.assertTrue(self.plan1.is_full()) """ Tests that the signin limiting works correctly. """ def test_signin_limit(self): self.plan1.signin_limit = 2 user = Membership(first_name="Testy", last_name="Testerson", email="*****@*****.**", plan="plan1") user.put() # We should have all 2 signins left. self.assertEqual(2, Plan.signins_remaining(user)) # Signin once. user.signins = 1 user.put() self.assertEqual(1, Plan.signins_remaining(user)) # Signin again. user.signins = 2 user.put() self.assertEqual(0, Plan.signins_remaining(user)) # Should never be less than zero. user.signins = 3 user.put() self.assertEqual(0, Plan.signins_remaining(user)) # Give ourselves unlimited signins! self.plan1.signin_limit = None self.assertEqual(None, Plan.signins_remaining(user)) """ Tests that it correctly detects when we can and can't put people on various plans. """ def test_can_subscribe(self): self.assertTrue(Plan.can_subscribe("plan1")) self.assertTrue(Plan.can_subscribe("plan2")) self.assertFalse(Plan.can_subscribe("plan3")) self.assertFalse(Plan.can_subscribe("plan4")) self.assertFalse(Plan.can_subscribe("plan5")) # Test that it lets us sign up for plan 5 if we are an admin. self.testbed.setup_env(user_is_admin="1") self.assertTrue(Plan.can_subscribe("plan5")) """ Tests that it correctly counts members from normal plans and their legacy versions together. """ def test_legacy_pairing(self): self.plan1.member_limit = 2 user1 = Membership(first_name="Testy1", last_name="Testerson", email="*****@*****.**", plan="plan1") user1.put() user2 = Membership(first_name="Testy2", last_name="Testerson", email="*****@*****.**", plan="plan4") user2.put() self.assertTrue(self.plan1.is_full()) """ Tests that it correctly fails to include members who have been suspended for too long when it checks if a plan is full. """ def test_ignore_long_suspensions(self): # Ensure that we have a known value for when we start ignoring plans. conf = Config() conf.PLAN_USER_IGNORE_THRESHOLD = 30 self.plan1.member_limit = 1 user = Membership(first_name="Testy", last_name="Testerson", email="*****@*****.**", plan="plan1", status="active") user.put() # Initially, the plan should be full, for every status. self.assertTrue(self.plan1.is_full()) user.status = "suspended" user.put() self.assertTrue(self.plan1.is_full()) user.status = None user.put() self.assertTrue(self.plan1.is_full()) # If we mess with the updated time, it should be ignored when the plan is # not active. user.updated = datetime.datetime.now() - datetime.timedelta(days=31) user.status = "active" user.put(skip_time_update=True) self.assertTrue(self.plan1.is_full()) user.status = "suspended" user.put(skip_time_update=True) self.assertFalse(self.plan1.is_full()) user.status = None user.put(skip_time_update=True) self.assertFalse(self.plan1.is_full()) """ Tests that plan aliases work as expected. """ def test_aliases(self): self.plan1.aliases = ["alias"] plan1 = Plan.get_by_name("alias") self.assertEqual(self.plan1, plan1) """ Tests that we can get all the plan ids as expected. """ def test_get_all_plan_ids(self): ids = Plan.get_all_plan_ids() self.assertEqual([("plan1", "plan1"), ("plan2", "plan2"), ("plan3", "plan3"), ("plan4", "plan4"), ("plan5", "plan5")], ids)
class PlanTests(unittest.TestCase): """ Set up for every test. """ def setUp(self): # Create and activate testbed instance. self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() # Clear all the real plans. Plan.all_plans = [] Plan.legacy_pairs.clear() # Make some test plans. self.plan1 = Plan("plan1", 1, 25, "Test plan 1") self.plan2 = Plan("plan2", 2, 50, "Test plan 2", selectable=False) self.plan3 = Plan("plan3", 3, 100, "Test plan 3", full=True) self.plan4 = Plan("plan4", 4, 75, "Test plan 4", legacy=self.plan1) self.plan5 = Plan("plan5", 5, 100, "Test plan 5", admin_only=True) """ Cleanup for every test. """ def tearDown(self): self.testbed.deactivate() """ Tests that we can get a list of plans to display on the plan selection page. """ def test_selection_page(self): active, hidden = Plan.get_plans_to_show() self.assertEqual([self.plan1], active) self.assertEqual([self.plan3], hidden) """ Tests that setting a member limit works. """ def test_member_limit(self): self.plan1.member_limit = 2 # Put some people in the datastore. user1 = Membership(first_name="Testy1", last_name="Testerson", email="*****@*****.**", plan="plan1") user2 = Membership(first_name="Testy2", last_name="Testerson", email="*****@*****.**", plan="plan1") # The plan should not be full initially. self.assertFalse(self.plan1.is_full()) # Adding one user should still not make it full. user1.put() self.assertFalse(self.plan1.is_full()) # Adding the other user should make it full. user2.put() self.assertTrue(self.plan1.is_full()) """ Tests that the signin limiting works correctly. """ def test_signin_limit(self): self.plan1.signin_limit = 2 user = Membership(first_name="Testy", last_name="Testerson", email="*****@*****.**", plan="plan1") user.put() # We should have all 2 signins left. self.assertEqual(2, Plan.signins_remaining(user)) # Signin once. user.signins = 1 user.put() self.assertEqual(1, Plan.signins_remaining(user)) # Signin again. user.signins = 2 user.put() self.assertEqual(0, Plan.signins_remaining(user)) # Should never be less than zero. user.signins = 3 user.put() self.assertEqual(0, Plan.signins_remaining(user)) # Give ourselves unlimited signins! self.plan1.signin_limit = None self.assertEqual(None, Plan.signins_remaining(user)) """ Tests that it correctly detects when we can and can't put people on various plans. """ def test_can_subscribe(self): self.assertTrue(Plan.can_subscribe("plan1")) self.assertTrue(Plan.can_subscribe("plan2")) self.assertFalse(Plan.can_subscribe("plan3")) self.assertFalse(Plan.can_subscribe("plan4")) self.assertFalse(Plan.can_subscribe("plan5")) # Test that it lets us sign up for plan 5 if we are an admin. self.testbed.setup_env(user_is_admin="1") self.assertTrue(Plan.can_subscribe("plan5")) """ Tests that it correctly counts members from normal plans and their legacy versions together. """ def test_legacy_pairing(self): self.plan1.member_limit = 2 user1 = Membership(first_name="Testy1", last_name="Testerson", email="*****@*****.**", plan="plan1") user1.put() user2 = Membership(first_name="Testy2", last_name="Testerson", email="*****@*****.**", plan="plan4") user2.put() self.assertTrue(self.plan1.is_full()) """ Tests that it correctly fails to include members who have been suspended for too long when it checks if a plan is full. """ def test_ignore_long_suspensions(self): # Ensure that we have a known value for when we start ignoring plans. conf = Config() conf.PLAN_USER_IGNORE_THRESHOLD = 30 self.plan1.member_limit = 1 user = Membership(first_name="Testy", last_name="Testerson", email="*****@*****.**", plan="plan1", status="active") user.put() # Initially, the plan should be full, for every status. self.assertTrue(self.plan1.is_full()) user.status = "suspended" user.put() self.assertTrue(self.plan1.is_full()) user.status = None user.put() self.assertTrue(self.plan1.is_full()) # If we mess with the updated time, it should be ignored when the plan is # not active. user.updated = datetime.datetime.now() - datetime.timedelta(days=31) user.status = "active" user.put(skip_time_update=True) self.assertTrue(self.plan1.is_full()) user.status = "suspended" user.put(skip_time_update=True) self.assertFalse(self.plan1.is_full()) user.status = None user.put(skip_time_update=True) self.assertFalse(self.plan1.is_full()) """ Tests that plan aliases work as expected. """ def test_aliases(self): self.plan1.aliases = ["alias"] plan1 = Plan.get_by_name("alias") self.assertEqual(self.plan1, plan1) """ Tests that we can get all the plan ids as expected. """ def test_get_all_plan_ids(self): ids = Plan.get_all_plan_ids() self.assertEqual([("plan1", "1"), ("plan2", "2"), ("plan3", "3"), ("plan4", "4"), ("plan5", "5")], ids)
def test_get_all_plan_ids(self): ids = Plan.get_all_plan_ids() self.assertEqual([("plan1", "1"), ("plan2", "2"), ("plan3", "3"), ("plan4", "4"), ("plan5", "5")], ids)