def test_request_reset_password(client: TestClient, db: Session) -> None:
new_password = utils.random_lower_string()
confirm_password = new_password
user = utils.create_random_user(db)
user = utils.activate_random_user(db, user)
token_1 = security.generate_token(str(uuid4()), "reset",
datetime.utcnow() + timedelta(hours=2))
token_2 = security.generate_token(str(user.id), "reset",
datetime.utcnow() + timedelta(hours=2))
response_1 = client.post('/sessions/reset-password',
json={
"new_password": new_password,
"confirm_password": confirm_password,
"token": token_1
})
response_2 = client.post('/sessions/reset-password',
json={
"new_password": new_password,
"confirm_password": confirm_password,
"token": token_2
})
db.refresh(user)
assert response_1.status_code == 404
assert response_2.status_code == 200
assert security.verify_password(new_password, user.hashed_password)
def login_access_token(
data: SessionLogin,
db: Session = Depends(deps.get_db)) -> Any:
"""
Endpoint for access token
"""
user = crud_user.get_user_by_email(db, data.email)
credentials_exception = HTTPException(status_code=400, detail="E-mail ou senha incorretos!")
if not user:
raise credentials_exception
if not security.verify_password(data.password, user.hashed_password):
raise credentials_exception
if not user.is_active:
raise HTTPException(status_code=401, detail="Este e-mail ainda não foi verificado. Verifique sua caixa de entrada")
if not user.address and data.host == "web":
raise HTTPException(status_code=401, detail="Versão web e apenas para cabeleireiros, porfavor user a versão mobile")
session = {
"user": jsonable_encoder(user),
"token": security.generate_token(str(user.id), 'access', datetime.utcnow() + timedelta(days=1))
}
return session
def create_user(
data: UserCreate,
background_tasks: BackgroundTasks,
db: Session = Depends(deps.get_db),
rdc: RedisCache = Depends(deps.get_redis)
) -> Any:
"""
Endpoint for create user
"""
user = crud_user.get_user_by_email(db, data.email)
if user:
raise HTTPException(status_code=400,
detail='Endereço de email já registrador!')
user = crud_user.create(db, data)
rdc.invalidate_cache_prefix("providers-list")
token = security.generate_token(str(user.id), "activate",
datetime.utcnow() + timedelta(days=31))
background_tasks.add_task(mail.send_account_activation_email, user.name,
user.email, token)
return {
'detail':
'Enviamos um e-mail para você confirma seu cadastro, por favor verifique sua caixa de entrada.'
}
def test_list_provider_hours_availability(client: TestClient,
db: Session) -> None:
user = utils.create_random_user(db)
user = utils.activate_random_user(db, user)
provider = utils.create_random_provider(db)
provider = utils.activate_random_user(db, provider)
appointment = utils.create_random_appointment(db, provider, user)
token = security.generate_token(str(provider.id), "access",
datetime.utcnow() + timedelta(hours=2))
header = {'Authorization': f'Bearer {token}'}
day = appointment.date.day
month = appointment.date.month
year = appointment.date.year
response = client.get(
f"/providers/day-availability?provider_id=2deee015-b1dd-4d08-8ce6-99b17a7477a8&day={day}&month={month}&year={year}",
headers=header)
data = response.json()
assert response.status_code == 200
assert data
assert "hour" in data[0]
assert "available" in data[0]
db.delete(user)
db.delete(provider)
db.delete(appointment)
db.commit()
def test_update_users(client: TestClient, db: Session) -> None:
name = utils.random_lower_string()
surname = utils.random_lower_string()
address = utils.random_lower_string()
user_1 = utils.create_random_user(db)
user_2 = utils.create_random_user(db)
provider = utils.create_random_provider(db)
token_1 = security.generate_token(str(user_1.id), 'access', datetime.utcnow() + timedelta(days=1))
token_2 = security.generate_token(str(provider.id), 'access', datetime.utcnow() + timedelta(days=1))
header_1 = {'Authorization': f'Bearer {token_1}'}
header_2 = {'Authorization': f'Bearer {token_2}'}
# Update user with existing email
response_1 = client.put('/users', headers=header_1, json={
"name": name,
"surname": surname,
"email": user_2.email,
})
# Update user normally
response_2 = client.put('/users', headers=header_1, json={
"name": name,
"surname": surname,
"email": user_1.email,
})
# Update provider normally
response_3 = client.put('/users', headers=header_2, json={
"name": name,
"surname": surname,
"address": address,
"email": provider.email,
})
assert response_1.status_code == 400
data_1 = response_2.json()
assert response_2.status_code == 200
assert data_1
assert data_1['name'] == name
assert data_1['surname'] == surname
data_2 = response_3.json()
assert response_3.status_code == 200
assert data_2
assert data_2['name'] == name
assert data_2['surname'] == surname
assert data_2['address'] == address
db.delete(provider)
db.commit()
def test_activate(client: TestClient, db: Session) -> None:
user_1 = utils.create_random_user(db)
user_2 = utils.create_random_user(db)
utils.activate_random_user(db, user_1)
token_1 = security.generate_token(str(user_1.id), "activate", datetime.utcnow() + timedelta(hours=2))
token_2 = security.generate_token(str(uuid4()), "activate", datetime.utcnow() + timedelta(hours=2))
token_3 = security.generate_token(str(user_2.id), "activate", datetime.utcnow() + timedelta(hours=2))
# User already active
response_1 = client.put("/users/activate", json={
"token": token_1
})
# User not found
response_2 = client.put("/users/activate", json={
"token": token_2
})
# Activate normally
response_3 = client.put("/users/activate", json={
"token": token_3
})
assert response_1.status_code == 400
assert response_2.status_code == 404
db.refresh(user_2)
assert response_3.status_code == 200
assert user_2.is_active == True
def request_forgot_password(
data: SessionForget,
background_tasks: BackgroundTasks,
db: Session = Depends(deps.get_db)
) -> Any:
"""
Endpoint for recovery password
"""
user = crud_user.get_user_by_email(db, data.email)
if not user:
raise HTTPException(status_code=404, detail="Usuário não encontrado!")
token = security.generate_token(str(user.id), "reset", datetime.utcnow() + timedelta(hours=2))
background_tasks.add_task(mail.send_reset_password_email, user.name, user.email, token)
return {'detail': 'E-mail de recuperação enviado, por favor verifique sua caixa de entrada'}
def test_list_providers(client: TestClient, db: Session) -> None:
user = utils.create_random_user(db)
user = utils.activate_random_user(db, user)
provider = utils.create_random_provider(db)
provider = utils.activate_random_user(db, provider)
token = security.generate_token(str(user.id), 'access',
datetime.utcnow() + timedelta(days=1))
header = {'Authorization': f'Bearer {token}'}
response = client.get('/providers', headers=header)
data = response.json()
assert response.status_code == 200
assert data
assert data[0]['id'] != str(user.id)
db.delete(user)
db.delete(provider)
db.commit()
def test_upload_avatar(client: TestClient, db: Session) -> None:
user = utils.create_random_user(db)
user = utils.activate_random_user(db, user)
token = security.generate_token(str(user.id), "access", datetime.utcnow() + timedelta(hours=2))
header = {'Authorization': f'Bearer {token}'}
file = settings.BASE_DIR.joinpath('app', 'tests', 'teste.jpg')
with open(file, "rb") as f:
response = client.put(
"/users/file",
headers=header,
files={"file": ("teste.jpg", f, "image/jpg")
})
data = response.json()
assert response.status_code == 200
assert "avatar" in data
assert data["avatar"]
db.delete(user)
db.commit()
def test_get_user_me(client: TestClient, db: Session) -> None:
user = utils.create_random_user(db)
provider = utils.create_random_provider(db)
user = utils.activate_random_user(db, user)
provider = utils.activate_random_user(db, provider)
appointment = utils.create_random_appointment(db, provider, user)
user = utils.activate_random_user(db, user)
token = security.generate_token(str(user.id), "access", datetime.utcnow() + timedelta(hours=2))
header = {'Authorization': f'Bearer {token}'}
response = client.get("/users/me", headers=header)
data = response.json()
assert response.status_code == 200
assert data
assert data[0]['user_id'] == str(user.id)
assert "provider" in data[0]
db.delete(user)
db.delete(provider)
db.delete(appointment)
db.commit()
def test_update_notification(client: TestClient, db: Session) -> None:
user = utils.create_random_user(db)
user = utils.activate_random_user(db, user)
provider = utils.create_random_provider(db)
provider = utils.activate_random_user(db, provider)
notification = utils.create_random_notification(provider)
appointment = utils.create_random_appointment(db, provider, user)
token = security.generate_token(str(provider.id), "access",
datetime.utcnow() + timedelta(hours=2))
header = {'Authorization': f'Bearer {token}'}
response = client.put("/providers/notifications",
headers=header,
json={"doc_id": str(notification.id)})
document = Notification.objects(id=notification.id).first()
assert response.status_code == 204
assert document.read == True
db.delete(user)
db.delete(provider)
db.delete(appointment)
db.commit()
Notification.delete(notification)
def test_update_password(client: TestClient, db: Session) -> None:
old_password = utils.random_lower_string()
new_password = utils.random_lower_string()
user = utils.create_random_user(db, old_password)
user = utils.activate_random_user(db, user)
token = security.generate_token(str(user.id), "access", datetime.utcnow() + timedelta(hours=2))
header = {'Authorization': f'Bearer {token}'}
response_1 = client.put("/users/password", headers=header, json={
"old_password": utils.random_lower_string(),
"new_password": new_password,
"confirm_password": new_password,
})
response_2 = client.put("/users/password", headers=header, json={
"old_password": old_password,
"new_password": new_password,
"confirm_password": new_password,
})
assert response_1.status_code == 400
db.refresh(user)
assert response_2.status_code == 204
assert security.verify_password(new_password, user.hashed_password)
db.delete(user)
db.commit()
def test_get_provider_me(client: TestClient, db: Session) -> None:
user = utils.create_random_user(db)
user = utils.activate_random_user(db, user)
provider = utils.create_random_provider(db)
provider = utils.activate_random_user(db, provider)
appointment = utils.create_random_appointment(db, provider, user)
token = security.generate_token(str(provider.id), 'access',
datetime.utcnow() + timedelta(days=1))
header = {'Authorization': f'Bearer {token}'}
day = appointment.date.day
month = appointment.date.month
year = appointment.date.year
response = client.get(f'/providers/me?day={day}&month={month}&year={year}',
headers=header)
data = response.json()
assert response.status_code == 200
assert data
assert data[0]['provider_id'] == str(provider.id)
assert "user" in data[0]
db.delete(user)
db.delete(provider)
db.delete(appointment)
db.commit()