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 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.")
def post(self): user = users.get_current_user() if not user: self.redirect(users.create_login_url("/key")) return account = Membership.all().filter("username ="******"@")[0]).get() if not account or not account.spreedly_token or account.status != "active": message = "Error #1982, which should never happen." internal = True self.response.out.write(self.render("templates/error.html", locals())) return is_park = self.request.get("ispark") if is_park == "True": # checks if user input is a parking pass number or an rfid number pass_to_add = self.request.get("parking_pass") try: # tests if there are only numbers in the parking pass float(pass_to_add) except ValueError: message = '<p>A Parking Pass may only contain numbers.</p><a href="/key">Try Again</a>' internal = False self.response.out.write(self.render("templates/error.html", locals())) return account.parking_pass = pass_to_add logging.debug("Setting parking pass for %s to %s." % (account.full_name(), account.parking_pass)) db.put(account) self.response.out.write(self.render("templates/pass_ok.html", locals())) # outputs the parking number else: rfid_tag = self.request.get("rfid_tag").strip() description = self.request.get("description").strip() if rfid_tag.isdigit(): if Membership.all().filter("rfid_tag =", rfid_tag).get(): message = "<p>That RFID tag is in use by someone else.</p>" internal = False self.response.out.write(self.render("templates/error.html", locals())) return if not description: message = "<p>Please enter a reason why you are associating a replacement RFID key. Please hit BACK and try again.</p>" internal = False self.response.out.write(self.render("templates/error.html", locals())) return account.rfid_tag = rfid_tag logging.debug("Setting RFID for %s to %s." % (account.full_name(), account.rfid_tag)) account.put() bc = BadgeChange(rfid_tag=rfid_tag, username=account.username, description=description) bc.put() self.response.out.write(self.render("templates/key_ok.html", locals())) return else: message = "<p>That RFID ID seemed invalid. Hit back and try again.</p>" internal = False self.response.out.write(self.render("templates/error.html", locals())) return
class MembershipTest(unittest.TestCase): def setUp(self): """Setup method to instance an object of Membership class """ code = 9 name = "Gold" discount = 10 self.membership = Membership(code, name, discount) self.test_membership = Membership(5, "Platinum", 5) def test_create_membership(self): """Test if an instance is created with the required data""" self.assertIsInstance(self.test_membership, Membership) def test_set_code_of_membership(self): """Test to update the membership code""" other_code = 10 self.test_membership.set_code(other_code) self.assertEqual(other_code, self.test_membership.get_code()) def test_set_name_of_membership(self): """ Test to update the membership name""" other_name = "Platinum" self.test_membership.set_name(other_name) self.assertEqual(other_name, self.test_membership.get_name()) def test_set_discont_of_membership(self): """ Test to update the membership discount""" other_discount = 11 self.test_membership.set_discount(other_discount) self.assertEqual(other_discount, self.test_membership.get_discount())
def test_discount(self): # A unique number on all the giftcards. serial = "1678" # A "correct" hash, based on what the actual code does. correct_hash = hashlib.sha1(serial + self.code).hexdigest() correct_hash = re.sub("[a-f]", "", correct_hash)[:8] gift_code = "1337" + serial + correct_hash print "Using test gift code: %s" % (gift_code) # Now try using this code. user = Membership.get_by_hash(self.user_hash) user.referrer = gift_code user.put() response = self.test_app.post("/account/" + self.user_hash, self._TEST_PARAMS) self.assertEqual(302, response.status_int) # We should have a record of the used code. codes = main.UsedCode.all().run() for code in codes: # We should only have one code in there. self.assertEqual(gift_code, code.code) self.assertEqual("*****@*****.**", code.email) self.assertEqual("OK", code.extra) user = Membership.get_by_hash(self.user_hash) user.username = None user.put() # Try to use the same code again. response = self.test_app.post("/account/" + self.user_hash, self._TEST_PARAMS, expect_errors=True) self.assertEqual(422, response.status_int) self.assertIn("already been used", response.body) # Now we should have individual records of the same code being used twice. codes = main.UsedCode.all().run() # Turn the iterator into a list. codes = [code for code in codes] self.assertEqual(gift_code, codes[0].code) self.assertEqual(gift_code, codes[1].code) self.assertEqual("*****@*****.**", codes[0].email) self.assertEqual("*****@*****.**", codes[1].email) if codes[0].extra == "OK": # The other one should be the duplicate. self.assertEqual("2nd+ attempt", codes[1].extra) elif codes[0].extra == "2nd+ attempt": # The other one should be the good one. self.assertEqual("OK", codes[1].extra) else: fail("Got unexpected extra '%s'." % (codes[0].extra))
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 post(self): subscriber_ids = self.request.get("subscriber_ids").split(",") for id in subscriber_ids: logging.debug("Updating subscriber with id %s." % id) subscriber_api.update_subscriber(Membership.get_by_id(int(id))) self.response.out.write("ok")
def get(self): countdown = 0 for membership in Membership.all().filter("status =", None): if (datetime.datetime.now().date() - membership.created.date()).days > 1: countdown += 90 self.response.out.write("bye %s " % (membership.email)) taskqueue.add(url="/tasks/clean_row", params={"user": membership.key().id()}, countdown=countdown)
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 post(self): countdown = 0 for membership in Membership.all().filter('status =', None): if (datetime.now().date() - membership.created.date()).days > 1: countdown += 90 self.response.out.write("bye "+membership.email+ " ") taskqueue.add(url='/tasks/clean_row', params={'user': membership.key().id()}, countdown=countdown)
def post(self): user = Membership.get_by_id(int(self.request.get("user"))) try: mail.send_mail(sender=Config().EMAIL_FROM, to=user.email, subject="Hi again -- from Hacker Dojo!", body="Hi %s," "\nOur fancy membership system noted that you started filling" " out the Membership Signup form, but didn't complete it." "\nWell -- We'd love to have you as a member!" "\nHacker Dojo has grown by leaps and bounds in recent years." " Give us a try?" "\nIf you would like to become a member of Hacker Dojo, just" " complete the signup process at http://signup.hackerdojo.com" "\nIf you don't want to sign up -- please give us anonymous" " feedback so we know how we can do better! URL:" " http://bit.ly/jJAGYM" "\nCheers!\nHacker Dojo" "\n\nPS: Please ignore this e-mail if you already signed up --" " you might have started signing up twice or something :)" " PPS: This is an automated e-mail and we're now deleting your" " e-mail address from the signup application." % (user.full_name) ) except: noop = True user.delete()
def post(self, ids=None): subscriber_ids = self.request.get('subscriber_ids').split(',') c = Config() s = spreedly.Spreedly(c.SPREEDLY_ACCOUNT, token=c.SPREEDLY_APIKEY) for id in subscriber_ids: subscriber = s.subscriber_details(sub_id=int(id)) logging.debug("customer_id: "+ subscriber['customer-id']) member = Membership.get_by_id(int(subscriber['customer-id'])) if member: if member.status == 'paypal': mail.send_mail(sender=EMAIL_FROM, to=PAYPAL_EMAIL, subject="Please cancel PayPal subscription for %s" % member.full_name(), body=member.email) member.status = 'active' if subscriber['active'] == 'true' else 'suspended' if member.status == 'active' and not member.username: taskqueue.add(url='/tasks/create_user', method='POST', params={'hash': member.hash}, countdown=3) if member.status == 'active' and member.unsubscribe_reason: member.unsubscribe_reason = None member.spreedly_token = subscriber['token'] member.plan = subscriber['feature-level'] or member.plan if not subscriber['email']: subscriber['email'] = "*****@*****.**" member.email = subscriber['email'] member.put() # TODO: After a few months (now() = 06.13.2011), only suspend/restore if status CHANGED # As of right now, we can't trust previous status, so lets take action on each call to /update if member.status == 'active' and member.username: logging.info("Restoring User: "******"Suspending User: "******"ok")
def setUp(self): """Setup method to instance an object of Membership class """ code = 9 name = "Gold" discount = 10 self.membership = Membership(code, name, discount) self.test_membership = Membership(5, "Platinum", 5)
def test_create_user(self): response = self.test_app.post("/tasks/create_user", self.params) self.assertEqual(200, response.status_int) # Check that it's sending the right parameters to the domain app. self.assertIn("username=testy.testerson", response.body) self.assertIn("password=notasecret", response.body) self.assertIn("first_name=Testy", response.body) self.assertIn("last_name=Testerson", response.body) user = Membership.get_by_hash(self.user_hash) # Check that the user ended up with a username. self.assertEqual("testy.testerson", user.username) # Check that domain_user got set. self.assertTrue(user.domain_user) # Check that the password got cleared. self.assertEqual(None, user.password) # Check that it sent the right email. messages = self.mail_stub.get_sent_messages(to="*****@*****.**") self.assertEqual(1, len(messages)) # It should give the user this data. body = str(messages[0].body) self.assertIn(user.username, body)
def post(self): user_id = int(self.request.get("user")) logging.debug("Getting member with id: %d" % (user_id)) user = Membership.get_by_id(int(self.request.get("user"))) if not user: logging.error("Bad ID for member.") self.abort(422) logging.info("Sending email to %s %s." % \ (user.first_name, user.last_name)) subject = "Hacker Dojo Membership: ACTION REQUIRED" first_name = user.first_name subscribe_url = user.subscribe_url() unsubscribe_url = user.unsubscribe_url() body = self.render("templates/areyoustillthere.txt", locals()) to = "%s <%s>" % (user.full_name(), user.email) bcc = "%s <%s>" % ("Billing System", "*****@*****.**") if user.username: cc="%s <*****@*****.**>" % (user.full_name(), user.username), mail.send_mail(sender=Config().EMAIL_FROM_AYST, to=to, subject=subject, body=body, bcc=bcc, cc=cc) else: mail.send_mail(sender=Config().EMAIL_FROM_AYST, to=to, subject=subject, body=body, bcc=bcc)
def post(self): countdown = 0 for membership in Membership.all().filter('status =', "suspended"): if not membership.unsubscribe_reason and membership.spreedly_token and "Deleted" not in membership.last_name and membership.extra_dnd != True: countdown += 1200 # One e-mail every 20 min = 72 e-mails a day (100 is free appengine limit) self.response.out.write("Are you still there "+membership.email+ "?<br/>") taskqueue.add(url='/tasks/areyoustillthere_mail', params={'user': membership.key().id()}, countdown=countdown)
def test_user_suspending(self): user = Membership.get_by_email("*****@*****.**") # The next one should suspend us. user.signins = Config().LITE_VISITS - 1 user.put() params = {"email": "*****@*****.**"} response = self.test_app.post("/api/v1/signin", params) result = json.loads(response.body) self.assertEqual(200, response.status_int) self.assertEqual(0, result["visits_remaining"]) user = Membership.get_by_email("*****@*****.**") self.assertEqual(Config().LITE_VISITS, user.signins) self.assertEqual("no_visits", user.status)
def post(self): user = Membership.get_by_id(int(self.request.get('user'))) subject = "What's your twitter handle?" base = self.request.host body = render('templates/twittermail.txt', locals()) to = "%s <*****@*****.**>" % (user.full_name(), user.username) bcc = "%s <%s>" % ("Robot", "*****@*****.**") mail.send_mail(sender=EMAIL_FROM_AYST, to=to, subject=subject, body=body, bcc=bcc, html=body)
def test_user_suspending(self): user = Membership.get_by_email("*****@*****.**") # The next one should suspend us. user.signins = 9 user.rfid_tag = "1337" user.put() params = {"id": "1337"} response = self.test_app.post("/api/v1/rfid", params) result = json.loads(response.body) self.assertEqual(200, response.status_int) self.assertEqual(0, result["visits_remaining"]) user = Membership.get_by_email("*****@*****.**") self.assertEqual(10, user.signins) self.assertEqual("no_visits", user.status)
def get(self, hash): member = Membership.get_by_hash(hash) c = Config() if member: success_html = urlfetch.fetch(SUCCESS_HTML_URL).content success_html = success_html.replace('joining!', 'joining, %s!' % member.first_name) is_prod = c.is_prod self.response.out.write(render('templates/success.html', locals()))
def get(self, hash): member = Membership.get_by_hash(hash) conf = Config() if member: success_html = urlfetch.fetch(conf.SUCCESS_HTML_URL).content success_html = success_html.replace("joining!", "joining, %s!" % member.first_name) is_prod = conf.is_prod self.response.out.write(self.render("templates/success.html", locals()))
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): 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()
def get(self): user = users.get_current_user() if not user: self.redirect(users.create_login_url("/joinreasonlist")) if users.is_current_user_admin(): all_users = Membership.all().order("created").fetch(10000) self.response.out.write(self.render("templates/joinreasonlist.html", locals())) else: self.response.out.write("Need admin access")
def test_retry_no_token(self): # Make a user with no token. user = Membership.get_by_hash(self.user_hash) user.spreedly_token=None user.put() # Try to create an account for this user. response = self.test_app.post("/tasks/create_user", self.params) self.assertEqual(200, response.status_int) # We should have a new task now. taskqueue_stub = self.testbed.get_stub(testbed.TASKQUEUE_SERVICE_NAME) tasks = taskqueue_stub.GetTasks("default") self.assertEqual(1, len(tasks)) # The user shouldn't have a domain account yet. user = Membership.get_by_hash(self.user_hash) self.assertFalse(user.domain_user)
def test_get(self): query = urllib.urlencode({"plan": "newhive"}) response = self.test_app.get("/account/%s?%s" % (self.user_hash, query)) self.assertEqual(200, response.status_int) # Our username should be templated in. self.assertIn("testy.testerson", response.body) user = Membership.get_by_hash(self.user_hash) self.assertEqual("newhive", user.plan)
def post(self): user = users.get_current_user() if not user: self.redirect(users.create_login_url('/key')) return account = Membership.all().filter('username ='******'templates/error.html', locals())) return is_park = self.request.get('ispark') if is_park == "True": #checks if user input is a parking pass number or an rfid number pass_to_add = self.request.get('parking_pass') try: #tests if there are only numbers in the parking pass float(pass_to_add) except ValueError: error = "<p>A Parking Pass may only contain numbers.</p><a href=\"/key\">Try Again</a>" self.response.out.write(render('templates/error.html', locals())) return account.parking_pass = pass_to_add db.put(account) self.response.out.write(render('templates/pass_ok.html', locals())) #outputs the parking number else: rfid_tag = self.request.get('rfid_tag').strip() description = self.request.get('description').strip() if rfid_tag.isdigit(): if Membership.all().filter('rfid_tag =', rfid_tag).get(): error = "<p>That RFID tag is in use by someone else.</p>" self.response.out.write(render('templates/error.html', locals())) return if not description: error = "<p>Please enter a reason why you are associating a replacement RFID key. Please hit BACK and try again.</p>" self.response.out.write(render('templates/error.html', locals())) return account.rfid_tag = rfid_tag account.put() bc = BadgeChange(rfid_tag = rfid_tag, username=account.username, description=description) bc.put() self.response.out.write(render('templates/key_ok.html', locals())) return else: error = "<p>That RFID ID seemed invalid. Hit back and try again.</p>" self.response.out.write(render('templates/error.html', locals())) return
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_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)
def test_signin(self): params = {"email": "*****@*****.**"} response = self.test_app.post("/api/v1/signin", params) result = json.loads(response.body) self.assertEqual(Config().LITE_VISITS - 1, result["visits_remaining"]) # Check that our user signing in got recorded. user = Membership.get_by_email("*****@*****.**") self.assertEqual(1, user.signins)
def get(self): user = users.get_current_user() if not user: self.redirect(users.create_login_url("/profile")) return else: account = Membership.get_by_email(user.email()) email = "%s@%s" % (account.username, Config().APPS_DOMAIN) gravatar_url = "http://www.gravatar.com/avatar/" + hashlib.md5(email.lower()).hexdigest() self.response.out.write(self.render("templates/profile.html", locals()))
def test_post(self): query = urllib.urlencode(self._TEST_PARAMS) response = self.test_app.post("/account/" + self.user_hash, query) self.assertEqual(302, response.status_int) user = Membership.get_by_hash(self.user_hash) # We should be redirected to a personal spreedly page. self.assertIn("subs.pinpayments.com", response.location) self.assertIn(self.test_plan.plan_id, response.location) self.assertIn(str(user.key().id()), response.location) self.assertIn("testy.testerson", response.location) # The account information should be in the datastore. user = Membership.get_by_hash(self.user_hash) self.assertEqual("testy.testerson", user.username) self.assertEqual("notasecret", user.password) # We shouldn't have a domain account yet. self.assertFalse(user.domain_user)
def test_already_active(self): user = Membership.get_by_hash(self.user_hash) user.status = "active" user.put() query = urllib.urlencode(self._TEST_PARAMS) response = self.test_app.post("/account/" + self.user_hash, query) self.assertEqual(302, response.status_int) self.assertIn("success", response.location) self.assertIn(self.user_hash, response.location)
def __init__(self, attributes): self.name = attributes.get('name') self.cpf = attributes.get('name') self.billingAddress = Address(attributes.get('billingAddress')) if (attributes.get('membership') != None): self.membership = Membership(attributes.get('membership'))
def __batch_loop(self, cursor = None, *args, **kwargs): cursor = cursor while True: if (args == () and kwargs == {}): query = Membership.all() else: query = Membership.all().filter(*args, **kwargs) query.with_cursor(start_cursor = cursor) members = query.fetch(self.batch_size) if len(members) == 0: break for member in members: member = self.__strip_sensitive(member) self.__post_member(member) cursor = query.cursor() run_info = SyncRunInfo.all().get() run_info.cursor = cursor run_info.put()
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)
def get(self): user = users.get_current_user() if not user: self.redirect(users.create_login_url("/profile")) return else: account = Membership.get_by_email(user.email()) email = "%s@%s" % (account.username, Config().APPS_DOMAIN) gravatar_url = "http://www.gravatar.com/avatar/" + \ hashlib.md5(email.lower()).hexdigest() self.response.out.write( self.render("templates/profile.html", locals()))
def test_bad_length_code(self): code = "133712345" user = Membership.get_by_hash(self.user_hash) user.referrer = code user.put() response = self.test_app.post("/account/" + self.user_hash, self._TEST_PARAMS, expect_errors=True) self.assertEqual(422, response.status_int) self.assertIn("must be 16 digits", response.body)
def test_invalid_code(self): code = "1337424242424242" user = Membership.get_by_hash(self.user_hash) user.referrer = code user.put() response = self.test_app.post("/account/" + self.user_hash, self._TEST_PARAMS, expect_errors=True) self.assertEqual(422, response.status_int) self.assertIn("code was invalid", response.body)
def test_post(self): response = self.test_app.post("/", self._TEST_PARAMS) self.assertEqual(302, response.status_int) # It should have put an entry in the datastore. user = Membership.get_by_email("*****@*****.**") self.assertNotEqual(None, user) self.assertEqual("Testy", user.first_name) self.assertEqual("Testerson", user.last_name) self.assertEqual("ttesterson", user.twitter) self.assertEqual("My mom", user.referrer) self.assertNotEqual(None, user.hash)
def get(self): countdown = 0 for membership in Membership.all().filter("status =", "suspended"): if (not membership.unsubscribe_reason and membership.spreedly_token \ and "Deleted" not in membership.last_name and \ membership.extra_dnd != True): # One e-mail every 90 seconds = 960 e-mails a day. countdown += 90 self.response.out.write("Are you still there %s ?<br/>" % \ (membership.email)) taskqueue.add(url="/tasks/areyoustillthere_mail", params={"user": membership.key().id()}, countdown=countdown)
def get(self, hash): membership = Membership.get_by_hash(hash) if not membership: self.response.set_status(422) self.response.out.write("Unknown member hash.") logging.error("Could not find member with hash '%s'." % (hash)) return # Save the plan they want. plan = self.request.get("plan", "newfull") membership.plan = plan membership.put() if ((membership.username and membership.password) and not \ membership.spreedly_token): # We've filled out our account information, but we never started a # subscription. (This could be reached by going back and trying to # change our plan after we were already taken to the PinPayments # page.) In this case, just pass them through to PinPayments. self.redirect( membership.new_subscribe_url(self.request.host, plan=plan)) # steal this part to detect if they registered with hacker dojo email above 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() usernames = self.fetch_usernames() if usernames == None: # Error page is already rendered. return if username in usernames: # Duplicate username. Use the first part of the email instead. username = membership.email.split("@")[0].lower() user_number = 0 base_username = username while username in usernames: # Still a duplicate. Add a number. user_number += 1 username = "******" % (base_username, user_number) if self.request.get("pick_username"): pick_username = True account_url = str("/account/%s" % membership.hash) self.response.out.write(self.render("templates/account.html", locals()))
def get(self, user_hash): member = Membership.get_by_hash(user_hash) if not member: # Hash is invalid. logging.error("Invalid hash '%s'." % (user_hash)) error = self.render("templates/error.html", message="Invalid reactivation link.") self.response.out.write(error) self.response.set_status(422) return self._plan_switch_page(member)
def test_suspended_user(self): user = Membership.get_by_email("*****@*****.**") user.status = "suspended" user.put() params = {"email": "*****@*****.**"} response = self.test_app.post("/api/v1/signin", params, expect_errors=True) result = json.loads(response.body) self.assertEqual(422, response.status_int) self.assertIn("Could not find", result["message"])
def test_cleanup(self): response = self.test_app.post("/tasks/clean_row", self.params) self.assertEqual(200, response.status_int) # Make sure the user is gone. user = Membership.get_by_id(self.user_id) self.assertEqual(None, user) # Make sure our email got sent and looks correct. messages = self.mail_stub.get_sent_messages(to=self.user.email) self.assertEqual(1, len(messages)) body = str(messages[0].body) self.assertIn(self.user.full_name(), body)
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 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 test_bad_user_id(self): params = {"user": "******"} response = self.test_app.post("/tasks/clean_row", params) # The status should still be okay, because we don't want it to retry in this # case. self.assertEqual(200, response.status_int) # The user should still be there. user = Membership.get_by_id(self.user_id) self.assertNotEqual(None, user) # No email should have gotten sent. messages = self.mail_stub.get_sent_messages(to=self.user.email) self.assertEqual(0, len(messages))
def create(cls, user_name, email, password=None, locale=None, openid_identity=None, global_admin=False): from group import Group from membership import Membership from openid import OpenID import adhocracy.lib.util as util if password is None: password = util.random_token() import adhocracy.i18n as i18n if locale is None: locale = i18n.get_default_locale() user = User(user_name, email, password, locale) meta.Session.add(user) default_group = Group.by_code(Group.CODE_DEFAULT) default_membership = Membership(user, None, default_group) meta.Session.add(default_membership) if global_admin: admin_group = Group.by_code(Group.CODE_ADMIN) admin_membership = Membership(user, None, admin_group) meta.Session.add(admin_membership) if openid_identity is not None: openid = OpenID(unicode(openid_identity), user) meta.Session.add(openid) meta.Session.flush() return user
def post(self, id): member = Membership.get_by_id(int(id)) if member: unsubscribe_reason = self.request.get("unsubscribe_reason") if unsubscribe_reason: member.unsubscribe_reason = unsubscribe_reason member.put() self.response.out.write( self.render("templates/unsubscribe_thanks.html", locals())) else: self.response.out.write( self.render("templates/unsubscribe_error.html", locals())) else: self.response.out.write( "error: could not locate your membership record.")
def test_already_entered(self): user = Membership.get_by_hash(self.user_hash) user.username = "******" user.password = "******" user.spreedly_token = None user.put() response = self.test_app.get("/account/" + self.user_hash, self._TEST_PARAMS) # We should be redirected to a personal spreedly page. self.assertEqual(302, response.status_int) self.assertIn("subs.pinpayments.com", response.location) self.assertIn(self.test_plan.plan_id, response.location) self.assertIn(str(user.key().id()), response.location) self.assertIn("testy.testerson", response.location)
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 setUp(self): super(MemberListHandlerTest, self).setUp() # This handler requires admin access all the time, so give ourselves that # right off the bat. self.testbed.setup_env(user_email="*****@*****.**", user_is_admin="1", overwrite=True) # Make exactly two pages worth of users. for i in range(0, 50): email = "*****@*****.**" % (i) first_name = "Testy%d" % (i) user = Membership.create_user(email, "notasecret", first_name=first_name, last_name="Testerson", status="active")
def create(cls, key, label, user, description=None, locale=None): from group import Group from membership import Membership from page import Page instance = Instance(unicode(key).lower(), label, user) instance.description = description instance.default_group = Group.by_code(Group.INSTANCE_DEFAULT) if locale is not None: instance.locale = locale meta.Session.add(instance) supervisor_group = Group.by_code(Group.CODE_SUPERVISOR) membership = Membership(user, instance, supervisor_group, approved=True) meta.Session.add(membership) Page.create(instance, label, u"", user) meta.Session.flush() return instance
def test_trivial_failures(self): # Give it a bad hash. bad_params = {"hash": "badhash"} response = self.test_app.post("/tasks/create_user", bad_params, expect_errors=True) self.assertEqual(422, response.status_int) # Give it a user with a username already. user = Membership.get_by_hash(self.user_hash) user.username = "******" user.put() response = self.test_app.post("/tasks/create_user", self.params) # This should be okay, because we don't want PinPayments to think it needs # to retry the call. self.assertEqual(200, response.status_int)
def get(self): suspended_users = Membership.all().filter("status =", "suspended").filter( "last_name !=", "Deleted").fetch(10000) tokened_users = [] for user in suspended_users: if user.spreedly_token: tokened_users.append(user) suspended_users = sorted(tokened_users, key=lambda user: user.last_name.lower()) total = len(suspended_users) reasonable = 0 for user in suspended_users: if user.unsubscribe_reason: reasonable += 1 self.response.out.write( self.render("templates/suspended.html", locals()))
def get(self): active_users = Membership.all().filter("status =", "active").filter( "plan =", "hardship").fetch(10000) active_users = sorted(active_users, key=lambda user: user.created) subject = "About your Hacker Dojo membership" body1 = "\n\nWe hope you have enjoyed your discounted membership at \ Hacker Dojo. As you\nknow, we created the hardship program \ to give temporary financial support to help\nmembers get \ started at the Dojo. Our records show you began the program\n \ on" body2 = ", and we hope you feel that you have benefited.\n\nBeginning \ with your next month's term, we ask that you please sign up \ at\nour regular rate:\n" body3 = "\n\nThank you for supporting the Dojo!" self.response.out.write( self.render("templates/hardship.html", locals()))