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