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_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 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_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_aliases(self):
self.plan1.aliases = ["alias"]
plan1 = Plan.get_by_name("alias")
self.assertEqual(self.plan1, plan1)
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", "1"), ("plan2", "2"), ("plan3", "3"),
("plan4", "4"), ("plan5", "5")], ids)
