def test_logout_successfully(self): """ Com: um novo usuário (com email confirmado). Quando: usuario faz login, e depois logout Verificamos: a operação (logout) é realizada com sucesso """ # with login_url = url_for('admin.login_view') logout_url = url_for('admin.logout_view') credentials = { 'email': '*****@*****.**', 'password': '******', } expected_page_header = u'<h1>OPAC Admin <small>da coleção: %s</small></h1>' % \ current_app.config['OPAC_COLLECTION'].upper() # when create_user(credentials['email'], credentials['password'], True) login_response = self.client.post(login_url, data=credentials, follow_redirects=True) self.assertStatus(login_response, 200) logout_response = self.client.get(logout_url, follow_redirects=True) # then self.assertStatus(logout_response, 200) self.assertTemplateUsed('admin/auth/login.html')
def test_reset_password_with_unconfirmed_email_shows_unconfirm_email_error(self): """ Com: um novo usuário (com email NÃO confirmado), Quando: 1. solicitamos recuperar senha. 2. obtemos o email com a url necessária para recuperação. 3. e solicitamos uma nova senha, com o link (token) do email. Verificamos: - a pagina deve informar que é necessário confirmar o email. - a troca de senha não procede. - a pagina deve mostrar o template admin/auth/unconfirm_email.html """ # with reset_pwd_url = url_for('admin.reset') credentials = { 'email': '*****@*****.**', 'password': '******' } # when create_user(credentials['email'], credentials['password'], False) with mail.record_messages() as outbox: response = self.client.post( reset_pwd_url, data={'email': credentials['email']}, follow_redirects=True) # then # no foi enviado nenhum email self.assertEqual(0, len(outbox)) self.assertStatus(response, 200) self.assertTemplateUsed('admin/auth/unconfirm_email.html') user = get_user_by_email(credentials['email']) self.assertTrue(user.is_correct_password(credentials['password']))
def post(self, request): form = SignUpForm(request.POST, request.FILES) form.fields['payment_methods'].choices = self.choices_pay if form.is_valid(): if password_confirmed(form.cleaned_data): return render(request, 'app/signup.html', { 'message': 'Las contraseñas no coinciden', 'form': form }) try: tipo = form.cleaned_data['type'] create_user(tipo, form) return render(request, 'app/login.html', { 'message': 'Cuenta creada satisfactoriamente', 'form': form, }) except IntegrityError: return render(request, 'app/signup.html', { 'message': 'El usuario ya esta en uso', 'form': form }) except KeyError as e: return render(request, 'app/signup.html', { 'message': e.args[0], 'form': form }) else: form = LoginForm() return render(request, 'app/login.html', { 'form': form, })
def test_login_successfully(self): """ Com: um novo usuário (com email confirmado) Quando: o novo usuário faz login Verificamos: - a página visualizada corresponde ao admin/index - a página visualizada contem link para fazer logout. """ # with login_url = url_for('admin.login_view') credentials = { 'email': '*****@*****.**', 'password': '******', } expected_page_header = u'<h1>OPAC Admin <small>da coleção: %s</small></h1>' % \ current_app.config['OPAC_COLLECTION'].upper() expected_logout_url = url_for('admin.logout_view') # when create_user( credentials['email'], credentials['password'], True) # create new user: response = self.client.post(login_url, data=credentials, follow_redirects=True) # then self.assertStatus(response, 200) self.assertTemplateUsed('admin/index.html') self.assertIn(expected_page_header, response.data.decode('utf-8')) self.assertIn(expected_logout_url, response.data.decode('utf-8'))
def test_reset_password_of_valid_user_proceed_ok(self): """ Com: um novo usuário (com email confirmado). Quando: solicitamos a recuperação de senha. Verificamos: A notifiação (flash) na página de que foram enviadas as instruções para o email do novo usuário. """ credentials = { 'email': '*****@*****.**', 'password': '******' } # with reset_pwd_url = url_for('admin.reset') expected_msg = u'Enviamos as instruções para recuperar a senha para: %s' % \ credentials['email'] # when create_user(credentials['email'], credentials['password'], True) response = self.client.post( reset_pwd_url, data={'email': credentials['email']}, follow_redirects=True) # then self.assertStatus(response, 200) self.assertTemplateUsed('admin/auth/login.html') self.assertIn(expected_msg, response.data.decode('utf-8'))
def register(): # UPLOAD_FOLDER = '/path/to/the/uploads' # ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg', 'gif']) if request.method == 'GET': return render_template('register.html') if request.method == 'POST': veteran = { 'username': request.form['username'].lower(), 'name': request.form['name'], 'skills': request.form['skills'], 'years_served': request.form['years_served'], 'rank': request.form['rank'], 'branch': request.form['branch'], 'bio': request.form['bio'], 'contact': request.form['contact'], 'image': "default.png" } pass_hash = find_hash(request.form['password']) create_user(veteran, pass_hash) session['username'] = veteran['username'] flash("Successfully registered you, " + veteran['name']) redirect_url = "/veteran/" + veteran['username'] return redirect(redirect_url, code=302)
def test_reset_password_with_unconfirmed_email_raise_validation_error_2(self): """ Com: um novo usuário (com email confirmado), Quando: 1. solicitamos recuperar senha. 2. obtemos o email com a url necessária para recuperação. 3. mudamos o usuário para ter seu email como NÃO confirmado. 4. e solicitamos uma nova senha, com o link (token) do email. Verificamos: - a pagina deve informar que é necessário confirmar o email. - a troca de senha não procede. - a pagina deve mostrar o template admin/auth/unconfirm_email.html """ # with reset_pwd_url = url_for('admin.reset') credentials = { 'email': '*****@*****.**', 'password': '******' } # when create_user(credentials['email'], credentials['password'], True) with mail.record_messages() as outbox: response = self.client.post( reset_pwd_url, data={'email': credentials['email']}, follow_redirects=True) # then self.assertEqual(1, len(outbox)) email_msg = outbox[0] # recupero os links do email links_found = reset_pwd_url_pattern.findall(email_msg.html) # tem pelo menos 1 link, e tem só um link para o reset/password com token self.assertGreaterEqual(1, len(links_found)) resert_url_with_token = [url for url in links_found if reset_pwd_url in url][0] # agora o usuário tem o email NÃO confirmado. user = get_user_by_email(credentials['email']) user.email_confirmed = False dbsql.session.add(user) dbsql.session.commit() # tentamos recuperar a senha com o link/token do email new_password = '******' response = self.client.post( resert_url_with_token, data={'password': new_password}, follow_redirects=True) self.assertStatus(response, 200) self.assertTemplateUsed('admin/auth/unconfirm_email.html') user = get_user_by_email(credentials['email']) self.assertTrue(user.is_correct_password(credentials['password']))
def test_try_to_create_user_without_email_must_raise_error_notification(self): """ Com: - usuario administrador (com email confirmado) Quando: 1. acessamos /admin 2. tentamos cadastrar um novo usuário, ** sem inserir email ** Verificamos: - o usuário não é criado. - o usuário administrado é notificodo do erro da operação. """ # with admin_user = { 'email': '*****@*****.**', 'password': '******', } create_user(admin_user['email'], admin_user['password'], True) new_user = { 'email': '*****@*****.**', 'password': '******' } login_url = url_for('admin.login_view') create_user_url = '/admin/user/new/' expected_form_error = {'email': [u'This field is required.']} # when with mail.record_messages() as outbox: with self.client as client: # login do usuario admin login_response = client.post( login_url, data=admin_user, follow_redirects=True) self.assertStatus(login_response, 200) self.assertTemplateUsed('admin/index.html') self.assertTrue(current_user.is_authenticated) # "preencher" from sem o email do novo usuário create_user_response = client.post( create_user_url, data={'email': ''}, follow_redirects=True) # then self.assertStatus(create_user_response, 200) self.assertTemplateUsed('admin/model/create.html') # tem erro no formulario context_form = self.get_context_variable('form') # self.assertIsInstance(context_form, admin_form.UserForm) self.assertEqual(expected_form_error, context_form.errors) # não temos email self.assertEqual(0, len(outbox))
def setUp(self): self.driver = webdriver.Firefox() self.user_name = 'username' self.user_pw = '%spw' % self.user_name utils.create_user(first='Jane', last='Doe', username=self.user_name) self.super_user_name = 'superuser' self.super_user_pw = '%spw' % self.super_user_name utils.create_super_user(first='Super', last='Woman', username=self.super_user_name) utils.create_users(users=utils.USERS) utils.create_issues(number_of_issues=10)
def populate_db(self): with self.app.app_context(): self.user1 = create_user('user1', 'pass1', 'user1') self.user2 = create_user('user2', 'pass2', 'user2') self.user3 = create_user('user3', 'pass3', 'user3') self.user4 = create_user('user4', 'pass4', 'user4') self.room1_id = make_room(self.user1, self.user2).id self.room2_id = make_room(self.user1, self.user3).id self.room3_id = make_room(self.user2, self.user3).id self.room4_id = make_room(self.user3, self.user4).id add_chat(self.user1, self.room1_id, 'message1') add_chat(self.user1, self.room1_id, 'message2') add_chat(self.user2, self.room1_id, 'message3') add_chat(self.user3, self.room2_id, 'message4')
def test_reset_password_with_invalid_password_raise_validation_error(self): """ Com: um novo usuário (com email confirmado), Quando: 1. solicitamos recuperar senha. 2. obtemos o email com a url necessária para recuperação. 3. e solicitamos uma nova senha, com o link do email. 4. inserimos uma senha inválida ('') Verificamos: - a pagina deve informar de que senha é requerida - a senha do usuário não deve ser modificada """ # with reset_pwd_url = url_for('admin.reset') credentials = { 'email': '*****@*****.**', 'password': '******' } # when create_user(credentials['email'], credentials['password'], True) with mail.record_messages() as outbox: response = self.client.post( reset_pwd_url, data={'email': credentials['email']}, follow_redirects=True) # then self.assertEqual(1, len(outbox)) email_msg = outbox[0] # recupero os links do email links_found = reset_pwd_url_pattern.findall(email_msg.html) # tem pelo menos 1 link, e tem só um link para o reset/password com token self.assertGreaterEqual(1, len(links_found)) resert_url_with_token = [url for url in links_found if reset_pwd_url in url][0] invalid_password = '' response = self.client.post( resert_url_with_token, data={'password': invalid_password}, follow_redirects=True) self.assertStatus(response, 200) context_form = self.get_context_variable('form') expected_form_error = {'password': [u'This field is required.']} self.assertEqual(expected_form_error, context_form.errors) self.assertIn(expected_form_error['password'][0], response.data.decode('utf-8')) user = get_user_by_email(credentials['email']) self.assertFalse(user.is_correct_password(invalid_password))
def test_link_sent_via_email_to_reset_password_works_fine(self): """ Com: um novo usuário (com email confirmado), Quando: 1. solicitamos recuperar senha. 2. obtemos o email com a url necessária para recuperação. 3. e solicitamos uma nova senha, com o link do email. 4. inserimos uma nova senha para o úsuario. Verificamos: - a pagina de recuperar senha tenha o form esperado. - a senha do usuário deve ser atualizada. """ # with reset_pwd_url = url_for('admin.reset') credentials = { 'email': '*****@*****.**', 'password': '******' } # when create_user(credentials['email'], credentials['password'], True) with mail.record_messages() as outbox: response = self.client.post( reset_pwd_url, data={'email': credentials['email']}, follow_redirects=True) # then self.assertEqual(1, len(outbox)) email_msg = outbox[0] # recupero os links do email links_found = reset_pwd_url_pattern.findall(email_msg.html) # tem pelo menos 1 link, e tem só um link para o reset/password com token self.assertGreaterEqual(1, len(links_found)) resert_url_with_token = [url for url in links_found if reset_pwd_url in url][0] new_password = '******' response = self.client.post( resert_url_with_token, data={'password': new_password}, follow_redirects=True) self.assertStatus(response, 200) # verificação da nova senha do usuario user = get_user_by_email(credentials['email']) self.assertTrue(user.is_correct_password(new_password))
def test_reset_password_send_valid_link_via_email(self): """ Com: um novo usuário (com email confirmado), Quando: solicitamos recuperar senha, e obtemos o email com a url necessária para concluir a operação. Verificamos: - o email enviado contém um link para recupear senha. - a pagina de recuparar senha com token seja a correta. """ # with reset_pwd_url = url_for('admin.reset') credentials = { 'email': '*****@*****.**', 'password': '******' } # when create_user(credentials['email'], credentials['password'], True) with mail.record_messages() as outbox: response = self.client.post( reset_pwd_url, data={'email': credentials['email']}, follow_redirects=True) # then self.assertEqual(1, len(outbox)) email_msg = outbox[0] # recupero os links do email links_found = reset_pwd_url_pattern.findall(email_msg.html) # tem pelo menos 1 link, e tem só um link para o reset/password com token self.assertGreaterEqual(1, len(links_found)) resert_url_with_token = [url for url in links_found if reset_pwd_url in url] self.assertEqual(1, len(resert_url_with_token)) resert_url_with_token = resert_url_with_token[0] # requisição de reset passoword com token reset_pwd_response = self.client.get( resert_url_with_token, follow_redirects=True) self.assertStatus(reset_pwd_response, 200) self.assertTemplateUsed('admin/auth/reset_with_token.html') context_form = self.get_context_variable('form') self.assertIsInstance(context_form, forms.PasswordForm)
def create_superuser(): """ Cria um novo usuário a partir dos dados inseridos na linha de comandos. Para criar um novo usuário é necessario preencher: - email (deve ser válido é único, se já existe outro usuário com esse email deve inserir outro); - senha (modo echo off) - e se o usuário tem email confirmado (caso sim, pode fazer logim, caso que não, deve verificar por email) """ user_email = None user_password = None while user_email is None: user_email = raw_input(u'Email: ').strip() if user_email == '': user_email = None print u'Email não pode ser vazio' else: form = EmailForm(data={'email': user_email}) if not form.validate(): user_email = None print u'Deve inserir um email válido!' elif controllers.get_user_by_email(user_email): user_email = None print u'Já existe outro usuário com esse email!' os.system("stty -echo") while user_password is None: user_password = raw_input(u'Senha: ').strip() if user_password == '': user_password = None print u'Senha não pode ser vazio' os.system("stty echo") email_confirmed = raw_input('\nEmail confirmado? [y/N]: ').strip() if email_confirmed.upper() in ('Y', 'YES'): email_confirmed = True else: email_confirmed = False print u'Deve enviar o email de confirmação pelo admin' # cria usuario utils.create_user(user_email, user_password, email_confirmed) print u'Novo usuário criado com sucesso!'
def test_login_with_unconfirmed_user_must_not_proceed(self): """ Com: um novo usuário (com email NÃO confirmado) Quando: o novo usuário faz login, com os dados certos Verificamos: - a página visualizada corresponde a admin/auth/unconfirm_email.html. - a página visualizada deve informar do erro. """ # with login_url = url_for('admin.login_view') credentials = { 'email': '*****@*****.**', 'password': '******', } expected_form_error = {'password': [u'Senha inválida']} expected_error_msgs = [ u"Email não confirmado!", u"Você <strong>deve</strong> confirmar seu email.<br>", u"<strong>Por favor entre em contato com o administrador.</strong>"] create_user( credentials['email'], credentials['password'], False) # when # create new user: response = self.client.post( login_url, data=credentials, follow_redirects=True) # then self.assertStatus(response, 200) self.assertTemplateUsed('admin/auth/unconfirm_email.html') for msg in expected_error_msgs: self.assertIn(msg, response.data.decode('utf-8')) context_form = self.get_context_variable('form') self.assertIsInstance(context_form, forms.LoginForm) self.assertEqual(expected_form_error, context_form.errors)
def test_user_list(self): with self.app.app_context(): create_user('user1', 'pass1', 'nick1') create_user('user2', 'pass2', 'nick2') create_user('user3', 'pass3', 'nick3') rv = self.test_app.post('/user/login', data=json.dumps({ 'username': '******', 'password': '******', }), content_type='application/json') access_token = json.loads(rv.data)['access_token'] rv = self.test_app.get('/user/list', headers={ 'authorization': 'JWT ' + access_token }) assert rv.status_code == 200 data = json.loads(rv.data) assert len(data) == 2 assert set([u['username'] for u in data]) == set(['user2', 'user3']) access_token = json.loads(self.test_app.post('/user/login', data=json.dumps({ 'username': '******', 'password': '******', }), content_type='application/json').data)['access_token'] rv = self.test_app.get('/user/list', headers={ 'authorization': 'JWT ' + access_token }) assert set([u['username'] for u in json.loads(rv.data)]) == set(['user1', 'user3'])
def test_login_valid_user_with_invalid_password_raise_error_msg(self): """ Com: um novo usuário (com email confirmado) Quando: o novo usuário faz login, mas com a senha errada Verificamos: - a página visualizada corresponde ao admin/index - a página visualizada deve informar de senha inválida """ # with login_url = url_for('admin.login_view') credentials = { 'email': '*****@*****.**', 'password': '******', } logged_page_header = u'<h1>OPAC Admin <small>da coleção: %s</small></h1>' % \ current_app.config['OPAC_COLLECTION'].upper() logout_url = url_for('admin.logout_view') # when create_user( credentials['email'], credentials['password'], True) # create new user: response = self.client.post( login_url, data={ 'email': credentials['email'], 'password': '******', }, follow_redirects=True) # then self.assertStatus(response, 200) self.assertTemplateUsed('admin/auth/login.html') self.assertNotIn(logged_page_header, response.data.decode('utf-8')) self.assertNotIn(logout_url, response.data.decode('utf-8'))
def test_reset_password_of_valid_user_email_sent(self): """ Com: um novo usuário (com email confirmado) Quando: solicitar a recuperação de senha Verificamos: Que a mensagem no email enviado contém o link para continuar a operação. """ # with reset_pwd_url = url_for('admin.reset') credentials = { 'email': '*****@*****.**', 'password': '******' } expected_email = { 'subject': 'Instruções para recuperar sua senha', 'recipients': [credentials['email'], ], 'body_has_link': u'<a href="http://localhost%s' % reset_pwd_url } # when create_user(credentials['email'], credentials['password'], True) with mail.record_messages() as outbox: response = self.client.post( reset_pwd_url, data={'email': credentials['email']}, follow_redirects=True) # then self.assertStatus(response, 200) self.assertEqual(1, len(outbox)) email_msg = outbox[0] self.assertEqual(expected_email['subject'], email_msg.subject) self.assertEqual(expected_email['recipients'], email_msg.recipients) self.assertIn(expected_email['body_has_link'], email_msg.html.decode('utf-8'))
def register(): form = RegisterForm(request.form) if not form.validate(): return make_response(jsonify(), 400) try: user = create_user(form.username.data, form.password.data, form.nickname.data) except Exception as e: print(e) return make_response(jsonify({ 'error': str(e), }), 400) return make_response(jsonify(), 200)
def test_create_user_from_admin_page_creates_a_new_user(self): """ Com: - usuario administrador (com email confirmado) Quando: 1. acessamos /admin e cadastramos um novo usuário 2. acesssamos o link enviado por email Verificamos: - o usuário é criado. - o usuário administrador é notificodo do sucesso da operação. - o novo usuário não tem email confirmado. - o novo usuário é notificado por email para confirmar email. """ # with admin_user = { 'email': '*****@*****.**', 'password': '******', } create_user(admin_user['email'], admin_user['password'], True) new_user = { 'email': '*****@*****.**', 'password': '******' } login_url = url_for('admin.login_view') create_user_url = '/admin/user/new/' expected_msgs = [ u'Enviamos o email de confirmação para: %s' % new_user['email'], u'Registro criado com sucesso.', ] # when with mail.record_messages() as outbox: with self.client as client: # login do usuario admin login_response = client.post( login_url, data=admin_user, follow_redirects=True) self.assertStatus(login_response, 200) self.assertTemplateUsed('admin/index.html') self.assertTrue(current_user.is_authenticated) # requisição da ação para enviar email de confirmação create_user_response = client.post( create_user_url, data={'email': new_user['email']}, follow_redirects=True) # then self.assertStatus(create_user_response, 200) self.assertTemplateUsed('admin/model/list.html') for msg in expected_msgs: self.assertIn(msg, action_response.data.decode('utf-8')) # temos um email self.assertEqual(1, len(outbox)) email_msg = outbox[0] # pegamos o link com token links_found = email_confirm_url_pattern.findall(email_msg.html) # tem pelo menos 1 link, e tem só um link para o reset/password com token self.assertGreaterEqual(1, len(links_found)) email_confirmation_url_with_token = [url for url in links_found if '/admin/confirm/' in url] # temos a url com o token self.assertEqual(1, len(email_confirmation_url_with_token)) email_confirmation_url_with_token = email_confirmation_url_with_token[0] self.assertIsNotNone(email_confirmation_url_with_token) self.assertFalse(email_confirmation_url_with_token == '') # acessamos o link do email user = get_user_by_email(new_user['email']) confirmation_response = self.client.get(email_confirmation_url_with_token, follow_redirects=True) self.assertStatus(confirmation_response, 200) self.assertTemplateUsed('admin/index.html') # confirmação com sucesso self.assertIn(expected_msg, confirmation_response.data.decode('utf-8')) # confirmamos alteração do usuário self.assertTrue(user.email_confirmed)
def init_user(): user = User.query.filter_by(email=FAKE_EMAIL).first() if not user: create_user(FAKE_NAME, FAKE_EMAIL, FAKE_PASSWORD)
def setUp(self): self.client = Client() self.admin_user = utils.create_superuser(**utils.ADMIN_PAYLOAD) self.client.force_login(self.admin_user) self.user = utils.create_user(**utils.USER_PAYLOAD)
def setUp(self): self.client = APIClient() self.user = utils.create_user(**utils.USER_PAYLOAD) self.client.force_authenticate(self.user) self.recipe = utils.create_recipe(self.user)
def loginCallback(): # Specify the state when creating the flow in the callback so that it can # verified in the authorization server response. state = session['state'] flow = google_auth_oauthlib.flow.Flow.from_client_config( app.config['GOOGLE_SECRETS_CONFIG'], scopes=app.config['AUTHORIZATION_SCOPE'], state=state ) flow.redirect_uri = flask.url_for('loginCallback', _external=True) # Probably the state is already verified in the above step err = validate_state_token(request, session) if err is not None: return error_response('Invalid state parameter.', err) # Use the authorization server's response to fetch the OAuth 2.0 tokens authorization_response = request.url token = flow.fetch_token(authorization_response=authorization_response) # print('--token:', token) # validate token, if success get the decoded payload payload, err = validate_access_token(token['id_token']) if err is not None: return error_response('Invalid credentials.', err) # alternatively, use the verify_oauth2_token function from the google-auth library # https://developers.google.com/identity/one-tap/android/idtoken-auth # it is also possible to use a tokeninfo endpoint to get the token ID details instead of parsing it yourself # https://www.oauth.com/oauth2-servers/signing-in-with-google/verifying-the-user-info/ # e.g.: https://www.googleapis.com/oauth2/v3/tokeninfo?id_token=eyJ... # TODO: Examine scopes of access granted by the user credentials = flow.credentials session['credentials'] = credentials_to_dict(credentials) # although it is possible to directly get name, email and profile picture info by decode id token # and is available in the payload, as a practice, we still make a request to the userinfo endpoint # to retrieve the data # https://www.oauth.com/oauth2-servers/signing-in-with-google/verifying-the-user-info/ access_token = token['access_token'] token_type = token['token_type'] # Bearer auth_header = {'Authorization': f'{token_type} {access_token}'} try: userinfo = requests.get(app.config['GOOGLE_OPENID_ENDPOINTS']['userinfo'], headers = auth_header) except: # TODO: explicitly include the exact exception # incase the stored URI did not work, fetch URI from discovery document userinfo_endpoint = get_openid_endpoint('userinfo_endpoint') userinfo = requests.get(userinfo_endpoint, headers = auth_header) if userinfo.status_code == 200: userinfo = userinfo.json() user = { 'name': userinfo['name'], 'email': userinfo['email'], 'picture': userinfo['picture'], 'email_verified': userinfo['email_verified'] } if not user['email_verified']: return flask.redirect(flask.url_for('showRestaurants')) else: user_id = get_user_id(user['email']) if not user_id: user_id = create_user(user) user['user_id'] = user_id session['user'] = user else: flask.redirect(flask.url_for('showRestaurants')) # TODO: login failed return flask.redirect(flask.url_for('showRestaurants'))
def test_confirmation_email_send_email_with_token(self): """ Com: - o usuário 'administrador' logado (email confirmado) - um novo usuário, com email NÃO confirmado Quando: 1. enviamos emails de confirmação (utilizando a ação do admin/user) 2. Verificamos: - que o email enviado contem um link para confirmar email. - o email é enviado para o destinatario certo. - após a operação, a página é a correta. - as notifiação para usuário deve ser mostrada na página. """ # with admin_user = { 'email': '*****@*****.**', 'password': '******', } create_user(admin_user['email'], admin_user['password'], True) normal_user = { 'email': '*****@*****.**', 'password': '******' } create_user(normal_user['email'], normal_user['password'], False) login_url = url_for('admin.login_view') action_payload = { 'action': 'confirm_email', 'rowid': get_user_by_email(normal_user['email']).id, 'url': '/admin/user/' } expected_email_sent_notifications = [ u"Enviamos o email de confirmação para: %s" % normal_user['email'], u"1 usuários foram notificados com sucesso!", ] expected_email = { 'subject': u'Confirmação de email', 'recipients': [normal_user['email'], ], } # when # login do usuario admin login_response = self.client.post( login_url, data=admin_user, follow_redirects=True) self.assertStatus(login_response, 200) self.assertTemplateUsed('admin/index.html') # requisição da ação para enviar email de confirmação with mail.record_messages() as outbox: action_response = self.client.post( '/admin/user/action/', data=action_payload, follow_redirects=True) # then self.assertStatus(action_response, 200) self.assertTemplateUsed('admin/model/list.html') for msg in expected_email_sent_notifications: self.assertIn(msg, action_response.data.decode('utf-8')) # temos um email self.assertEqual(1, len(outbox)) email_msg = outbox[0] # email enviado ao destinatario certo, com assunto certo self.assertEqual(expected_email['recipients'], email_msg.recipients) self.assertEqual(expected_email['subject'], email_msg.subject.decode('utf-8')) # pegamos o link com token links_found = email_confirm_url_pattern.findall(email_msg.html) # tem pelo menos 1 link, e tem só um link para o reset/password com token self.assertGreaterEqual(1, len(links_found)) email_confirmation_url_with_token = [url for url in links_found if '/admin/confirm/' in url] # temos a url com o token self.assertEqual(1, len(email_confirmation_url_with_token)) email_confirmation_url_with_token = email_confirmation_url_with_token[0] self.assertIsNotNone(email_confirmation_url_with_token) self.assertFalse(email_confirmation_url_with_token == '')
def test_open_confirm_url_with_token_sent_via_email_open_the_correct_page(self): """ Com: - o usuário 'administrador' logado (email confirmado) - um novo usuário, com email NÃO confirmado Quando: 1. enviamos emails de confirmação (utilizando a ação do admin/user) 2. acesssamos o link enviado por email Verificamos: - que o email enviado contem um link para confirmar email. - após acessar o link, a página é a correta. - após acessar o link, a págian mostra a notificação de operação ok. - após acessar o link, o usuário tem seu email confirmado. """ # with admin_user = { 'email': '*****@*****.**', 'password': '******', } create_user(admin_user['email'], admin_user['password'], True) normal_user = { 'email': '*****@*****.**', 'password': '******' } create_user(normal_user['email'], normal_user['password'], False) login_url = url_for('admin.login_view') action_payload = { 'action': 'confirm_email', 'rowid': get_user_by_email(normal_user['email']).id, 'url': '/admin/user/' } expected_msg = u'Email: %s confirmado com sucesso!' % normal_user['email'] # when # login do usuario admin login_response = self.client.post( login_url, data=admin_user, follow_redirects=True) self.assertStatus(login_response, 200) # requisição da ação para enviar email de confirmação with mail.record_messages() as outbox: action_response = self.client.post( '/admin/user/action/', data=action_payload, follow_redirects=True) # then self.assertStatus(action_response, 200) # temos um email self.assertEqual(1, len(outbox)) email_msg = outbox[0] # pegamos o link com token links_found = email_confirm_url_pattern.findall(email_msg.html) # tem pelo menos 1 link, e tem só um link para o reset/password com token self.assertGreaterEqual(1, len(links_found)) email_confirmation_url_with_token = [url for url in links_found if '/admin/confirm/' in url] # temos a url com o token self.assertEqual(1, len(email_confirmation_url_with_token)) email_confirmation_url_with_token = email_confirmation_url_with_token[0] # acessamos o link do email confirmation_response = self.client.get(email_confirmation_url_with_token, follow_redirects=True) self.assertStatus(confirmation_response, 200) self.assertTemplateUsed('admin/index.html') # confirmação com sucesso self.assertIn(expected_msg, confirmation_response.data.decode('utf-8')) # confirmamos alteração do usuário user = get_user_by_email(normal_user['email']) self.assertTrue(user.email_confirmed)
def setUp(self): self.client = APIClient() self.user = utils.create_user(**utils.USER_PAYLOAD) self.user2 = utils.create_user(**utils.USER_PAYLOAD_UPDATE) self.client.force_authenticate(self.user)
def setUp(self): self.user = utils.create_user(**utils.USER_PAYLOAD) self.superuser = utils.create_superuser(**utils.SUPERUSER_PAYLOAD)