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_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 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_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_request_forgot_password(client: TestClient, db: Session) -> None:
password = utils.random_lower_string()
user = utils.create_random_user(db, password)
user = utils.activate_random_user(db, user)
response_1 = client.post('/sessions/forgot-password',
json={
"email": user.email,
})
response_2 = client.post('/sessions/forgot-password',
json={
"email": utils.random_email(),
})
assert response_1.status_code == 200
assert response_2.status_code == 404
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 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()
def test_access_token(client: TestClient, db: Session) -> None:
password = utils.random_lower_string()
user = utils.create_random_user(db, password)
# Wrong email
response_1 = client.post('/sessions/access-token',
json={
"email": utils.random_email(),
"password": password,
"host": "mobile"
})
# Wrong password
response_2 = client.post('/sessions/access-token',
json={
"email": user.email,
"password": utils.random_lower_string(),
"host": "mobile"
})
# Email not yet verified
response_3 = client.post('/sessions/access-token',
json={
"email": user.email,
"password": password,
"host": "mobile"
})
# Wrong platform
response_4 = client.post('/sessions/access-token',
json={
"email": user.email,
"password": password,
"host": "web"
})
# All right
user = utils.activate_random_user(db, user)
response_5 = client.post('/sessions/access-token',
json={
"email": user.email,
"password": password,
"host": "mobile"
})
assert response_1.status_code == 400
assert response_2.status_code == 400
assert response_3.status_code == 401
assert response_4.status_code == 401
data = response_5.json()
assert response_5.status_code == 200
assert "user" in data
assert "token" in data
assert data["token"]
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_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()
