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_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_get_appointments_by_DMY(db: Session) -> None:
user = utils.create_random_user(db)
provider = utils.create_random_provider(db)
appointment = utils.create_random_appointment(db, provider, user)
date = appointment.date
query = ProviderDayAvailabilityQuery(
provider_id=str(provider.id),
day=date.day,
month=date.month,
year=date.year)
my_appointment_1 = crud_appointment.get_appointments_by_DMY(db, query)
my_appointment_2 = crud_appointment.get_appointments_by_DMY(db, query, provider)
assert str(my_appointment_1[0].provider_id) == query.provider_id
assert my_appointment_1[0].date.day == query.day
assert my_appointment_1[0].date.month == query.month
assert my_appointment_1[0].date.year == query.year
assert my_appointment_2[0].provider_id == provider.id
assert my_appointment_2[0].date.day == query.day
assert my_appointment_2[0].date.month == query.month
assert my_appointment_2[0].date.year == query.year
db.delete(appointment)
db.delete(user)
db.delete(provider)
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_get_appointments_by_user(db: Session) -> None:
user = utils.create_random_user(db)
provider = utils.create_random_provider(db)
appointment = utils.create_random_appointment(db, provider, user)
user_appointments = crud_appointment.get_appointments_by_user(db, user)
assert user_appointments[0].user_id == user.id
db.delete(appointment)
db.delete(user)
db.delete(provider)
db.commit()
def test_invalidate_cache_user(db: Session, rdc: RedisCache) -> None:
user = utils.create_random_user(db)
provider = utils.create_random_provider(db)
appointment = utils.create_random_appointment(db, provider, user)
provider.provider_appointments.append(appointment)
key = f"user-appointments:{str(user.id)}"
value = 40
rdc.setex(key, timedelta(seconds=3600), value=pickle.dumps(value))
cache = rdc.get(key)
assert cache
rdc.invalidate_cache_user(provider)
cache = rdc.get(key)
assert cache is None
def test_create_link(client: TestClient, db: Session) -> None:
user, password = create_random_user(db)
headers = get_user_auth_headers(user.username, password, client)
title = random_lower_string()
url = "https://example.com"
data = {"title": title, "url": url}
response = client.post("/links", json=data, headers=headers)
assert response.status_code == 200
json = response.json()
assert json["title"] == title
assert json["url"] == url
assert not json["liked"]
assert not json["archived"]
def test_get_appointment_by_date(db: Session) -> None:
user = utils.create_random_user(db)
provider = utils.create_random_provider(db)
appointment = utils.create_random_appointment(db, provider, user)
date = appointment.date
date_appointment = crud_appointment.get_appointment_by_date(db, str(provider.id), date)
assert date_appointment.provider_id == provider.id
assert date_appointment.date == date
db.delete(appointment)
db.delete(user)
db.delete(provider)
db.commit()
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_create_appointment(db: Session) -> None:
user = utils.create_random_user(db)
provider = utils.create_random_provider(db)
date = datetime.now(timezone.utc)
appointment_in = AppointmentCreate(provider_id=provider.id, date=date)
appointment = crud_appointment.create(db, appointment_in, user)
assert appointment
assert appointment.provider_id == provider.id
assert appointment.date == date
assert appointment.user_id == user.id
db.delete(appointment)
db.delete(user)
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 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_access_token(client: TestClient, db: Session) -> None:
user, password = create_random_user(db)
data = {"username": user.username, "password": password}
response = client.post("/login/token", data=data)
assert response.status_code == 200
json = response.json()
assert "access_token" in json
assert json["access_token"]
token = json["access_token"]
headers = {"Authorization": f"Bearer {token}"}
response = client.post("/login/test-token", headers=headers)
assert response.status_code == 200
json = response.json()
assert "username" in json
assert json["username"] == user.username
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_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_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_create_users(client: TestClient, db: Session) -> None:
name = utils.random_lower_string()
surname = utils.random_lower_string()
email = utils.random_lower_string()
password = utils.random_lower_string()
user_2 = utils.create_random_user(db)
response_1 = client.post('/users', json={
"name": name,
"surname": surname,
"email": user_2.email,
"password": password,
"confirm_password": password
})
response_2 = client.post('/users', json={
"name": name,
"surname": surname,
"email": email,
"password": password,
"confirm_password": password
})
assert response_1.status_code == 400
assert response_2.status_code == 201
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_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()
