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_notification(db: Session) -> None:
provider = utils.create_random_provider(db)
notification = utils.create_random_notification(provider)
crud_notification.update(notification.id)
update_notification = Notification.objects(id=notification.id).first()
assert update_notification
db.delete(provider)
db.commit()
Notification.delete(notification)
def test_get_all_notifications(db: Session) -> None:
provider = utils.create_random_provider(db)
document = utils.create_random_notification(provider)
provider_notifications = crud_notification.get_all_notifications(str(provider.id))
assert provider_notifications
assert provider_notifications[0]['id'] == document.id
assert provider_notifications[0]['recipient_id'] == str(provider.id)
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_create_notification(db: Session) -> None:
provider = utils.create_random_provider(db)
message = utils.random_lower_string()
document_id = crud_notification.create(str(provider.id), message)
notification = Notification.objects(id=document_id).first()
assert notification
assert notification.content == message
assert notification.recipient_id == str(provider.id)
db.delete(provider)
db.commit()
Notification.delete(notification)
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_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_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_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_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_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_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()
