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)
