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()