def post(self): if Config().is_dev: # Only allow this if it's the dev server. entry = self.request.body logging.debug("Got new entry: " + entry) entry = json.loads(entry) # Change formatted date back into datetime. for key in entry.keys(): if type(getattr(Membership, key)) == db.DateTimeProperty: if not entry[key]: # It could be None as well. continue entry[key] = pickle.loads(str(entry[key])) # entry should have everything nicely in a dict... member = Membership(**entry) # Is this an update or a new model? match = Membership.all().filter("email =", member.email).get() if match: # Replace the old one. logging.debug("Found entry with same username. Replacing...") db.delete(match) member.put() logging.debug("Put entry in datastore.")
class ApiTest(unittest.TestCase): 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 tearDown(self): self.testbed.deactivate()
class BaseTest(unittest.TestCase): def setUp(self): # Set up testing for application. self.test_app = webtest.TestApp(tasks.app) # Set up datastore for testing. self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() self.testbed.init_taskqueue_stub() self.testbed.init_mail_stub() self.testbed.init_memcache_stub() # Add a user to the datastore. self.user = Membership(first_name="Testy", last_name="Testerson", email="*****@*****.**", hash="notahash", spreedly_token="notatoken", username="******", password="******") self.user.put() self.mail_stub = self.testbed.get_stub(testbed.MAIL_SERVICE_NAME) def tearDown(self): self.testbed.deactivate()
class ReactivatePlanHandlerTest(PlanSelectionTestBase): def setUp(self): super(ReactivatePlanHandlerTest, self).setUp() # Add a user to test with. self.user = Membership(first_name="Testy", last_name="Testerson", email="*****@*****.**", plan="plan1", spreedly_token="notatoken", hash="notahash", username="******") self.user.put() """ Tests that the page works properly when we give it the right things. """ def test_get(self): response = self.test_app.get("/reactivate_plan/%s" % (self.user.hash)) self.assertEqual(200, response.status_int) """ Tests that it fails when we give it a bad hash. """ def test_bad_hash(self): response = self.test_app.get("/reactivate_plan/badhash", expect_errors=True) self.assertEqual(422, response.status_int) self.assertIn("Invalid reactivation link", response.body)
class BaseTest(unittest.TestCase): def setUp(self): # Set up testing for application. self.test_app = webtest.TestApp(billing.app) # Set up datastore for testing. self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() self.testbed.init_user_stub() # Make some testing plans. self.test_plan = plans.Plan("test", 0, 150, "This is a test plan.") self.test_plan_legacy = plans.Plan("test_legacy", 1, 100, "This is a test plan.", legacy=self.test_plan) # Make a test user. self.user = Membership(email="*****@*****.**", first_name="Testy", last_name="Testerson", username="******", spreedly_token="notatoken", plan="test") self.user.put() # Simulate the user login. self.testbed.setup_env(user_email=self.user.email, user_is_admin="0", overwrite=True) def tearDown(self): self.testbed.deactivate()
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())
def test_failure_if_account(self): 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="******") existing_user.put() response = self.test_app.post("/", self._TEST_PARAMS, expect_errors=True) self.assertEqual(422, response.status_int) self.assertIn("payment", response.body)
def setUp(self): super(CreateUserTaskTest, self).setUp() # Add a user to the datastore. user = Membership(first_name="Testy", last_name="Testerson", email="*****@*****.**", hash="notahash", spreedly_token="notatoken", username="******", password="******") user.put() self.mail_stub = self.testbed.get_stub(testbed.MAIL_SERVICE_NAME) self.user_hash = user.hash self.params = {"hash": self.user_hash, "username": "******", "password": "******"}
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 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 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 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())
def test_skip_if_account(self): plan = Plan("test", 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)
class ApiTest(unittest.TestCase): 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 = 10) # Add a user to the datastore. self.user = Membership(first_name="Daniel", last_name="Petti", email="*****@*****.**", plan="test", username="******") self.user.put() def tearDown(self): self.testbed.deactivate()
class ResetSigninHandlerTest(unittest.TestCase): def setUp(self): # Set up testing application. self.test_app = webtest.TestApp(cron.app) # Set up datastore for testing. self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() # Add a user to the datastore. self.user = Membership(first_name="Testy", last_name="Testerson", email="*****@*****.**") self.user.put() """ Tests that the cron job restores users properly. """ def test_user_restore(self): self.user.signins = Config().LITE_VISITS + 2 self.user.status = "no_visits" self.user.put() response = self.test_app.get("/cron/reset_signins") self.assertEqual(200, response.status_int) user = Membership.get_by_email("*****@*****.**") self.assertEqual(0, user.signins) self.assertEqual("active", user.status) """ Tests that unused signins rollover properly. """ 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_already_existing(self): # Make a user in the datastore with the same email, but a different name so # we can see whether it overrides. existing_user = Membership(first_name="Michael", last_name="Scarn", email=self._TEST_PARAMS["email"], status="active") existing_user.put() # Because the user is active, it should prohibit us from overriding. response = self.test_app.post("/", self._TEST_PARAMS, expect_errors=True) self.assertEqual(422, response.status_int) self.assertIn("already exists", response.body) # User should stay the same. user = Membership.get_by_email(self._TEST_PARAMS["email"]) self.assertEqual("Michael", user.first_name) self.assertEqual("Scarn", user.last_name) existing_user.status = "suspended" existing_user.put() # Even though the user is suspended, it should still prohibit us from # overriding. response = self.test_app.post("/", self._TEST_PARAMS, expect_errors=True) self.assertEqual(422, response.status_int) self.assertIn("suspended", response.body) # User should stay the same. user = Membership.get_by_email(self._TEST_PARAMS["email"]) self.assertEqual("Michael", user.first_name) self.assertEqual("Scarn", user.last_name) existing_user.status = None existing_user.put() # Now the user should get silently overriden. response = self.test_app.post("/", self._TEST_PARAMS) self.assertEqual(302, response.status_int) # User should not stay the same. user = Membership.get_by_email(self._TEST_PARAMS["email"]) self.assertEqual(self._TEST_PARAMS["first_name"], user.first_name) self.assertEqual(self._TEST_PARAMS["last_name"], user.last_name)
class ResetSigninHandlerTest(unittest.TestCase): def setUp(self): # Set up testing application. self.test_app = webtest.TestApp(cron.app) # Set up datastore for testing. self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_datastore_v3_stub() # Add a user to the datastore. self.user = Membership(first_name="Testy", last_name="Testerson", email="*****@*****.**") self.user.put() """ Tests that the cron job restores users properly. """ def test_user_restore(self): self.user.signins = Config().LITE_VISITS + 2 self.user.status = "no_visits" self.user.put() response = self.test_app.get("/cron/reset_signins") self.assertEqual(200, response.status_int) user = Membership.get_by_email("*****@*****.**") self.assertEqual(0, user.signins) self.assertEqual("active", user.status) """ Tests that unused signins rollover properly. """ 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 post(self): refer = self.request.get('refer') first_name = self.request.get('first_name') last_name = self.request.get('last_name') twitter = self.request.get('twitter').lower().strip().strip('@') email = self.request.get('email').lower().strip() plan = self.request.get('plan', 'full') # See if the referring user is valid. try: ref_first_name = refer.split()[0] ref_last_name = refer.split()[1] referred_user = db.GqlQuery("SELECT * FROM Membership \ WHERE first_name = :first_name AND last_name = :last_name", first_name = ref_first_name, last_name = ref_last_name).get() except IndexError: referred_user = None if not first_name or not last_name or not email: self.response.out.write(render('templates/main.html', { 'plan': plan, 'message': "Sorry, we need name and e-mail address."})) elif (not referred_user and refer != ""): self.response.out.write(render('templates/main.html', { 'plan': plan, 'message': "The person who referred you is not an active user."})) else: # this just runs a check twice. (there is no OR in GQL) # first name, last name existing_member = db.GqlQuery("SELECT * FROM Membership WHERE first_name = :first_name AND last_name = :last_name", first_name=first_name, last_name=last_name).get() if existing_member: membership = existing_member # email existing_member = db.GqlQuery("SELECT * FROM Membership WHERE email = :email", email=email).get() if existing_member: membership = existing_member first_part = re.compile(r'[^\w]').sub('', first_name.split(' ')[0]) last_part = re.compile(r'[^\w]').sub('', last_name) if len(first_part)+len(last_part) >= 15: last_part = last_part[0] username = '******'.join([first_part, last_part]).lower() if username in fetch_usernames(): username = email.split('@')[0].lower() # [email protected] existing_member = db.GqlQuery("SELECT * FROM Membership WHERE email = :email", email='*****@*****.**' % username).get() if existing_member: membership = existing_member try: membership if membership.extra_dnd == True: self.response.out.write("Error #237. Please contact [email protected]") return if membership.status == "suspended": c = Config() self.redirect(str("https://www.spreedly.com/%s/subscriber_accounts/%s" % (c.SPREEDLY_ACCOUNT, membership.spreedly_token))) except NameError: membership = None # old code below #existing_member = Membership.get_by_email(email) #if existing_member and existing_member.status in [None, 'paypal']: # existing_member.delete() if membership is None: if referred_user: referuserid = referred_user.username else: referuserid = None membership = Membership( first_name=first_name, last_name=last_name, email=email, plan=plan, twitter=twitter, referuserid=referuserid) if self.request.get('paypal') == '1': membership.status = 'paypal' membership.hash = hashlib.md5(membership.email).hexdigest() if '1337' in self.request.get('referrer').upper(): membership.referrer = re.sub("[^0-9]", "", self.request.get('referrer').upper()) else: membership.referrer = self.request.get('referrer').replace('\n', ' ') membership.put() # if there is a membership, redirect here if membership.status != "active": #self.redirect(str('/account/%s' % membership.hash)) # HRD compatible hack, code taken from AccountHandler::get() first_part = re.compile(r'[^\w]').sub('', membership.first_name.split(' ')[0]) # First word of first name last_part = re.compile(r'[^\w]').sub('', membership.last_name) if len(first_part)+len(last_part) >= 15: last_part = last_part[0] # Just last initial username = '******'.join([first_part, last_part]).lower() if username in fetch_usernames(): username = membership.email.split('@')[0].lower() if self.request.get('u'): pick_username = True message = escape(self.request.get('message')) account_url = str('/account/%s' % membership.hash) self.response.out.write(render('templates/account.html', locals())) else: self.response.out.write(render('templates/main.html', {'message': 'The Email address is registered in our system.'}))
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())
def post(self): first_name = self.request.get("first_name") last_name = self.request.get("last_name") twitter = self.request.get("twitter").lower().strip().strip("@") email = self.request.get("email").lower().strip() plan = self.request.get("plan") if not first_name or not last_name or not email: self.response.out.write( self.render("templates/main.html", message="Sorry, we need name and email address.", plan=plan)) self.response.set_status(400) return membership = db.GqlQuery( "SELECT * FROM Membership WHERE email = :email", email=email).get() if membership: # A membership object already exists in the datastore. if membership.extra_dnd == True: self.response.out.write( "Error #237. Please contact [email protected]") self.response.set_status(422) return if membership.status == "suspended": self.response.out.write(self.render("templates/main.html", message="Your account has been suspended." \ " <a href=\"/reactivate\">Click here</a> to reactivate.", plan=plan)) self.response.set_status(422) return elif membership.status in ("active", "no_visits"): self.response.out.write( self.render("templates/main.html", message="Account already exists.", plan=plan)) self.response.set_status(422) return elif ((membership.username and membership.password and \ membership.plan) and not membership.spreedly_token): # They've already filled out everything, but they haven't started a # subscription. Take them to the PinPayments page. logging.info("Taking user %s directly to PinPayments page." % (membership.username)) self.redirect(membership.new_subscribe_url(self.request.host)) return else: # Existing membership never got activated. Overwrite it. logging.info("Overwriting existing membership for %s." % (email)) membership.first_name = first_name membership.last_name = last_name membership.email = email membership.twitter = twitter else: # Make a new membership object. membership = Membership(first_name=first_name, last_name=last_name, email=email, twitter=twitter) if self.request.get("paypal") == "1": membership.status = "paypal" membership.hash = hashlib.md5(membership.email).hexdigest() if "1337" in self.request.get("referrer").upper(): membership.referrer = re.sub("[^0-9]", "", self.request.get("referrer").upper()) else: membership.referrer = self.request.get("referrer").replace( "\n", " ") membership.put() logging.debug("Using plan: %s" % (plan)) if plan == "choose": # Have the user select a plan. self.redirect("/plan/%s" % (membership.hash)) else: # A plan was specified for us, so go on to creating the account. logging.info("Got plan '%s', skipping plan selection step." % (plan)) query = urllib.urlencode({"plan": plan}) self.redirect("/account/%s?%s" % (membership.hash, query))
def post(self): first_name = self.request.get("first_name") last_name = self.request.get("last_name") twitter = self.request.get("twitter").lower().strip().strip("@") email = self.request.get("email").lower().strip() plan = self.request.get("plan") if not first_name or not last_name or not email: self.response.out.write( self.render("templates/main.html", message="Sorry, we need name and email address.", plan=plan) ) self.response.set_status(400) return membership = db.GqlQuery("SELECT * FROM Membership WHERE email = :email", email=email).get() if membership: # A membership object already exists in the datastore. if membership.extra_dnd == True: self.response.out.write("Error #237. Please contact [email protected]") self.response.set_status(422) return if membership.status == "suspended": self.response.out.write( self.render( "templates/main.html", message="Your account has been suspended." ' <a href="/reactivate">Click here</a> to reactivate.', plan=plan, ) ) self.response.set_status(422) return elif membership.status in ("active", "no_visits"): self.response.out.write( self.render("templates/main.html", message="Account already exists.", plan=plan) ) self.response.set_status(422) return elif (membership.username and membership.password and membership.plan) and not membership.spreedly_token: # They've already filled out everything, but they haven't started a # subscription. Take them to the PinPayments page. logging.info("Taking user %s directly to PinPayments page." % (membership.username)) self.redirect(membership.new_subscribe_url(self.request.host)) return else: # Existing membership never got activated. Overwrite it. logging.info("Overwriting existing membership for %s." % (email)) membership.first_name = first_name membership.last_name = last_name membership.email = email membership.twitter = twitter else: # Make a new membership object. membership = Membership(first_name=first_name, last_name=last_name, email=email, twitter=twitter) if self.request.get("paypal") == "1": membership.status = "paypal" membership.hash = hashlib.md5(membership.email).hexdigest() if "1337" in self.request.get("referrer").upper(): membership.referrer = re.sub("[^0-9]", "", self.request.get("referrer").upper()) else: membership.referrer = self.request.get("referrer").replace("\n", " ") membership.put() logging.debug("Using plan: %s" % (plan)) if plan == "choose": # Have the user select a plan. self.redirect("/plan/%s" % (membership.hash)) else: # A plan was specified for us, so go on to creating the account. logging.info("Got plan '%s', skipping plan selection step." % (plan)) query = urllib.urlencode({"plan": plan}) self.redirect("/account/%s?%s" % (membership.hash, query))
class ChangePlanHandlerTest(PlanSelectionTestBase): def setUp(self): super(ChangePlanHandlerTest, self).setUp() # Add a user to test with. self.user = Membership(first_name="Testy", last_name="Testerson", email="*****@*****.**", plan="plan1", spreedly_token="notatoken", username="******") self.user.put() # Login our test user. self.testbed.init_user_stub() self.testbed.setup_env(user_email="*****@*****.**", overwrite=True) """ Tests that the plan selection page looks normal. """ def __check_page(self): response = self.test_app.get("/change_plan") self.assertEqual(200, response.status_int) # It should show the human name, and the link. (The plan ID should be in the # spreedly subscribe url.) self.assertIn(self.plan1.human_name, response.body) self.assertIn("subscribe/" + self.plan1.plan_id, response.body) self.assertIn(self.plan2.human_name, response.body) self.assertIn("subscribe/" + self.plan2.plan_id, response.body) # Not selectable, so it shouldn't be in there at all. self.assertNotIn(self.plan3.human_name, response.body) self.assertNotIn("subscribe/" + self.plan3.plan_id, response.body) # Unavailable, so the name should be there, but the link should not. self.assertIn(self.plan4.human_name, response.body) self.assertNotIn("subscribe/" + self.plan4.plan_id, response.body) # It should also show the price. self.assertIn("$%d" % (self.plan1.price_per_month), response.body) self.assertIn("$%d" % (self.plan2.price_per_month), response.body) self.assertNotIn("$%d" % (self.plan3.price_per_month), response.body) self.assertIn("$%d" % (self.plan4.price_per_month), response.body) """ Tests that the plans end up getting shown correctly. """ def test_plan_page(self): self.__check_page() """ Tests that it responds properly when the user has no spreedly token. """ def test_no_spreedly_token(self): self.user.spreedly_token = None self.user.put() response = self.test_app.get("/change_plan", expect_errors=True) self.assertEqual(422, response.status_int) self.assertIn("any plan", response.body) """ Tests that it deals with using the hackerdojo email properly. """ def test_hackerdojo_email(self): self.testbed.setup_env(user_email="*****@*****.**", overwrite=True) self.__check_page() """ Tests that it responds properly when an invalid person logs in. """ def test_invalid_email(self): self.testbed.setup_env(user_email="*****@*****.**", overwrite=True) response = self.test_app.get("/change_plan", expect_errors=True) self.assertEqual(422, response.status_int) self.assertIn("your email", response.body)