def test_timed_out_emailcheck_credentials_are_cleared_in_registration(self):
     for someone in User.query.all()[:5]:  # @UndefinedVariable
         Credential.new(someone, 'emailcheck', str(time.time()-1)+":"+uuid4().hex, uuid4().hex)
     self.assertTrue(self.countExpiredCreds('emailcheck')>=5)
     form = self.prepareLoginForm()
     self.controller.doRegistration(form)
     self.assertTrue(self.countExpiredCreds('emailcheck')==0)

 def you_can_login_using_facebook(self):
     if config.skipFacebookTests:
         return
     self.user = self.createUserWithCredentials("facebook", config.fbuserid, None, config.fbuser)
     self.user.activate()
     driver = self.driver
     driver.get(self.base_url+"/static/login.html")
     self.switchToTab("login")
     driver.find_element_by_id("Facebook_login_button").click()
     time.sleep(1)
     self._switchWindow(driver)
     driver.find_element_by_id("pass").clear()
     driver.find_element_by_id("pass").send_keys(config.fbpassword)
     driver.find_element_by_id("email").clear()
     driver.find_element_by_id("email").send_keys(config.fbuser)
     driver.find_element_by_id("u_0_2").click()
     driver.switch_to.window(self.master)
     time.sleep(1)
     self.assertEqual(self.base_url  + "/static/login.html", driver.current_url)
     body = driver.find_element_by_id("message").text
     self.assertEqual("", body)
     body = driver.find_element_by_id("userdata").text
     self.assertTrue("[email protected]"in body)
     Credential.getByUser(self.user, "facebook").rm()
     self.user.rm()

 def unregistered_user_can_register_with_facebook_in_the_middle_of_login_procedure_of_a_served_application(self):
     if config.skipFacebookTests:
         return
     driver = self.driver
     self._gotoOauthPage(driver)
     self.switchToTab('registration')
     driver.find_element_by_id("Facebook_registration_button").click()
     time.sleep(1)
     self.master = driver.current_window_handle
     timeCount = 1;
     while (len(driver.window_handles) == 1 ):
         time
         timeCount += 1
         if ( timeCount > 50 ): 
             break;
     for handle in driver.window_handles:
         if handle!=self.master:
             driver.switch_to.window(handle)
     driver.find_element_by_id("pass").clear()
     driver.find_element_by_id("pass").send_keys(config.fbpassword2)
     driver.find_element_by_id("email").clear()
     driver.find_element_by_id("email").send_keys(config.fbuser2)
     driver.find_element_by_id("u_0_2").click()
     driver.switch_to.window(self.master)
     time.sleep(5)
     self.assertTrue(driver.current_url.startswith(self.redirect_uri.lower()))
     self.user = User.getByEmail(config.fbuser2)
     Credential.getByUser(self.user, "facebook").rm()
     self.user.rm()

 def do_add_credential(self, form):
     user = self.getCurrentUser()
     Credential.new(user,
         form.credentialType.data,
         form.identifier.data,
         form.secret.data)
     return self.as_dict(user)

 def sendPasswordVerificationEmail(self, user):
     secret=unicode(uuid4())
     expiry = time.time() + 60*60*24*4
     Credential.new(user, 'emailcheck', unicode(expiry), secret )
     timeText = time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime(expiry))
     uri = "{0}/v1/verify_email/{1}".format(self.getConfig('BASE_URL'),secret)
     text = """Hi, click on <a href="{0}">{0}</a> until {1} to verify your email""".format(uri, timeText)
     self.mail.send_message(subject="verification", body=text, recipients=[user.email], sender=self.getConfig('SERVER_EMAIL_ADDRESS'))

 def test_the_credential_is_actually_added(self):
     myUserid = self.createRandomUserId()
     credBefore = Credential.get("password", myUserid)
     self.assertTrue(credBefore is None)
     resp = self._createPasswordCredential(userid=myUserid)
     self.assertEqual(200, resp.status_code)
     credAfter = Credential.get("password", myUserid)
     self.assertTrue(credAfter is not None)

 def doConfirmChangeEmail(self, secret=None, confirm=True, useverifysecret=False):
     self.controller.emailChangeInit(self.newEmailAddress, self.user)
     if secret is None:
         if useverifysecret:
             secret = Credential.getByUser(self.user, 'changeemailandverify').secret
         else:
             secret = Credential.getByUser(self.user, 'changeemail').secret
     return self.controller.confirmEmailChange(FakeForm(dict(confirm=confirm, secret=secret)))

 def test_password_reset_creates_password_if_it_does_not_exists(self):
     form = self.createPasswordResetFormWithSecret()
     user = User.getByEmail(self.userCreationEmail)
     passcred = Credential.getByUser(user, "password")
     passcred.rm()
     self.controller.doPasswordReset(form)
     newPassCred = Credential.getByUser(user, "password")
     self.assertEqual(newPassCred.secret, CredentialManager.protect_secret(self.newPassword))

 def _removeACredential(self, myUserid):
     self.controller.loginInFramework(self.cred)
     user = self.cred.user
     Credential.new(user, "facebook", myUserid, "testsecret")
     data = {"credentialType": "facebook",
         "identifier": myUserid}
     self.assertTrue(Credential.get("facebook", myUserid))
     resp = self.controller.doRemoveCredential(FakeForm(data))
     return resp

 def emailChangeInit(self, newEmailAddress, user):
     if User.getByEmail(newEmailAddress):
         raise ReportedError(thereIsAlreadyAUserWithThatEmail, 418)
     secret, expiry = CredentialManager.createTemporaryCredential(user, "changeemail",additionalInfo=newEmailAddress )
     self.sendEmail(user, secret, expiry, "CHANGE_EMAIL_OLD", newemail=newEmailAddress, oldemail=user.email )
     secret, expiry = CredentialManager.createTemporaryCredential(user, "changeemailandverify",additionalInfo=newEmailAddress )
     self.sendEmail(user, secret, expiry, "CHANGE_EMAIL_NEW", recipient=newEmailAddress, newemail=newEmailAddress, oldemail=user.email)
     Credential.deleteExpired("changeemail")
     Credential.deleteExpired("changeemailandverify")

 def do_password_reset(self, form):
     cred = Credential.get(passwordResetCredentialType, form.secret.data)
     if cred is None or (float(cred.secret) < time.time()):
         Credential.deleteExpired(passwordResetCredentialType)
         raise ReportedError(['The secret has expired'], 404)
     passcred = Credential.getByUser(cred.user, 'password')
     passcred.secret = CredentialManager.protect_secret(form.password.data)
     cred.rm()
     return self.simple_response('Password successfully changed')

 def removeFbuser(self,user=None):
     if user is None:
         user = config.facebookUser2
     self.user = User.getByEmail(user.email)
     if self.user:
         Credential.getByUser(self.user, "facebook").rm()
         for appMap in AppMap.getForUser(self.user):
             appMap.rm()
         self.user.rm()

 def no_password_reset_for_timed_out_temporary_credential(self):
     password = self.mkRandomPassword()
     secret = unicode(uuid4())
     user = User.getByEmail(self.usercreation_email)
     Credential.new(user, 'email_for_password_reset', secret, time.time()-1)
     with app.test_client() as c:
         data = dict(password=password, secret=secret)
         resp = c.post("/v1/password_reset", data = data)
         self.assertEqual(resp.status_code, 404)

 def successful_password_clears_the_temporary_credential(self):
     password = self.mkRandomPassword()
     secret = unicode(uuid4())
     user = User.getByEmail(self.usercreation_email)
     Credential.new(user, 'email_for_password_reset', secret, time.time()+3600)
     with app.test_client() as c:
         data = dict(password=password, secret=secret)
         c.post("/v1/password_reset", data = data)
         newcred = Credential.get('email_for_password_reset', secret)
         self.assertEquals(newcred, None)

 def successful_password_reset_sets_the_password(self):
     password = self.mkRandomPassword()
     secret = unicode(uuid4())
     user = User.getByEmail(self.usercreation_email)
     Credential.new(user, 'email_for_password_reset', secret, time.time()+3600)
     with app.test_client() as c:
         data = dict(password=password, secret=secret)
         c.post("/v1/password_reset", data = data)
         cred = Credential.getByUser(user, "password")
         self.assertEquals(cred.secret, CredentialManager.protect_secret(password))

 def test_bad_secret_clears_up_all_timed_out_temporary_credentials(self):
     password = self.mkRandomPassword()
     secret = uuid4().hex
     for someone in User.query.all()[:5]:  # @UndefinedVariable
         Credential.new(someone, 'email_for_password_reset', str(time.time()-1)+":"+uuid4().hex, uuid4().hex)
     self.assertTrue(self.countExpiredCreds()>=5)
     data = dict(password=password, secret=secret)
     self.assertReportedError(self.controller.doPasswordReset,(FakeForm(data),),
             404, ['The secret has expired'])
     self.assertEqual(self.countExpiredCreds(),0)

 def test_the_credential_used_for_login_cannot_be_cleared(self):
     credential = self.createUserWithCredentials()
     self.controller.loginInFramework(credential)
     self.assertTrue(Credential.get("password", self.userCreationUserid))
     form = FakeForm({
         "identifier": self.userCreationUserid,
         "credentialType": "password",
     })
     self.assertReportedError(self.controller.doRemoveCredential,[form], 400, ["You cannot delete the login you are using"])
     self.assertTrue(Credential.get("password", self.userCreationUserid))

 def do_send_password_reset_email(self, email):
     user = User.getByEmail(email)
     if user is None:
         raise ReportedError(['Invalid email address'])
     passwordResetEmailExpiration = 14400
     secret=unicode(uuid4())
     expirationTime = time.time() + passwordResetEmailExpiration
     Credential.new(user, passwordResetCredentialType, secret, unicode(expirationTime))
     self.sendPasswordResetMail(user, secret, expirationTime)
     return self.simple_response("Password reset email has successfully sent.")

 def findTemporaryEmailCredential(self, secret):
     cred = Credential.getBySecret("changeemail", secret)
     verify = False
     if cred is None:
         credverify = Credential.getBySecret("changeemailandverify", secret)
         if credverify is None:
             raise ReportedError(badChangeEmailSecret, 403)
         else:
             cred = credverify
             verify = True
     return cred, verify

 def test_valid_secret_is_accepted(self):
     password = self.mkRandomPassword()
     secret = uuid4().hex
     user = User.getByEmail(self.userCreationEmail)
     Credential.new(user, 'email_for_password_reset', str(time.time()+3600), secret)
     with app.test_client() as client:
         data = dict(password=password, secret=secret)
         resp = client.post("/v1/password_reset", data = data)
         self.assertEqual(resp.status_code, 200)
         respData = self.fromJson(resp)
         self.assertEqual("Password successfully changed",respData['message'])