async def test_get_user_returns_none_if_user_does_not_exist(init_db): db = init_db user_in = UserCreate(username=MOCK_USERNAME, password=MOCK_PASSWORD) await create_in_db(db, user_in=user_in) res = await get_user(db, "ghost") assert res == None
def test_check_if_user_is_active(): email = random_lower_string() password = random_lower_string() user_in = UserCreate(email=email, password=password) user = crud.user.create(db_session, user_in=user_in) is_active = crud.user.is_active(user) assert is_active is True
def test_create_user(): email = random_lower_string() password = random_lower_string() user_in = UserCreate(email=email, password=password) user = crud.user.create(db_session, user_in=user_in) assert user.email == email assert hasattr(user, "hashed_password")
def test_check_if_user_is_superuser_normal_user(): username = random_lower_string() password = random_lower_string() user_in = UserCreate(email=username, password=password) user = crud.user.create(db_session, user_in=user_in) is_superuser = crud.user.is_superuser(user) assert is_superuser is False
async def create_license_user( slug: str, data: UserCreate, current_user: User = Depends(get_current_active_user)): logging.info(">>> " + __name__ + ":create") slug = slug.strip().lower() # data.license = license logging.info(data) model = UserCreate(**data.dict()) # model.license = slug logging.info(model) user = await crud.find_by_email_or_username(data.email, data.username) if user: raise_bad_request( "Username or email is already registered in the system.") return await crud.insert_one(slug, model, license_owner=False)
async def test_get_user(init_db): db = init_db user_in = UserCreate(username=MOCK_USERNAME, password=MOCK_PASSWORD) await create_in_db(db, user_in=user_in) res = await get_user(db, MOCK_USERNAME) assert MOCK_USERNAME == res.username
async def test_authenticate_user_returns_none_if_pass_does_not_match(init_db): db = init_db user_in = UserCreate(username=MOCK_USERNAME, password=MOCK_PASSWORD) await create_in_db(db, user_in=user_in) res = await authenticate_user(db, MOCK_USERNAME, "nope") assert res == None
def test_check_if_user_is_superuser(): email = random_lower_string() password = random_lower_string() user_in = UserCreate(email=email, password=password, is_superuser=True) user = crud.user.create(db_session, user_in=user_in) is_superuser = crud.user.is_superuser(user) assert is_superuser is True
def test_get_user(): password = random_lower_string() username = random_lower_string() user_in = UserCreate(email=username, password=password, is_superuser=True) user = crud.user.create(db_session, user_in=user_in) user_2 = crud.user.get(db_session, user_id=users.id) assert user.email == user_2.email assert jsonable_encoder(user) == jsonable_encoder(user_2)
async def create_in_db(db: AsyncIOMotorDatabase, *, user_in: UserCreate) -> InsertOneResult: passwordhash = get_password_hash(user_in.password) user = UserInDB(**user_in.dict(), hashed_password=passwordhash) doc_data = jsonable_encoder(user) res = await db[USER_COLLECTION_NAME].insert_one(doc_data) return res
def test_retrieve_users(superuser_token_headers): server_api = get_server_api() username = random_lower_string() password = random_lower_string() user_in = UserCreate(email=username, password=password) user = crud.user.create(db_session, user_in=user_in) # noqa username2 = random_lower_string() password2 = random_lower_string() user_in2 = UserCreate(email=username2, password=password2) user2 = crud.user.create(db_session, user_in=user_in2) # noqa r = requests.get(f"{server_api}{config.API_V1_STR}/users/", headers=superuser_token_headers) all_users = r.json() assert len(all_users) > 1 for user in all_users: assert "email" in user
def create_random_user(): email = random_lower_string() password = random_lower_string() relation = random_lower_string() user_in = UserCreate(full_name=email, email=email, password=password, relation=relation) user = crud.user.create(db_session=db_session, user_in=user_in) return user
def test_check_if_user_is_active_inactive(): email = random_lower_string() password = random_lower_string() user_in = UserCreate(email=email, password=password, disabled=True) print(user_in) user = crud.user.create(db_session, user_in=user_in) print(user) is_active = crud.user.is_active(user) print(is_active) assert is_active
def test_authenticate_user(): email = random_lower_string() password = random_lower_string() user_in = UserCreate(email=email, password=password) user = crud.user.create(db_session, user_in=user_in) authenticated_user = crud.user.authenticate(db_session, email=email, password=password) assert authenticated_user assert user.email == authenticated_user.email
def test_create_user_by_normal_user(): server_api = get_server_api() username = random_lower_string() password = random_lower_string() user_in = UserCreate(email=username, password=password) user = crud.user.create(db_session, user_in=user_in) # noqa user_token_headers = user_authentication_headers(server_api, username, password) data = {"email": username, "password": password} r = requests.post(f"{server_api}{config.API_V1_STR}/users/", headers=user_token_headers, json=data) assert r.status_code == 400
async def test_user(db: Database) -> UserInDB: new_user = UserCreate( email="*****@*****.**", username="******", password="******", ) user_repo = UsersRepository(db) existing_user = await user_repo.get_user_by_email(email=new_user.email) if existing_user: return existing_user return await user_repo.register_new_user(new_user=new_user)
def test_get_existing_user(superuser_token_headers): server_api = get_server_api() username = random_lower_string() password = random_lower_string() user_in = UserCreate(email=username, password=password) user = crud.user.create(db_session, user_in=user_in) user_id = users.id r = requests.get( f"{server_api}{config.API_V1_STR}/users/{user_id}", headers=superuser_token_headers, ) assert 200 <= r.status_code < 300 api_user = r.json() user = crud.user.get_by_email(db_session, email=username) assert user.email == api_user["email"]
def test_create_user_existing_username(superuser_token_headers): server_api = get_server_api() username = random_lower_string() # username = email password = random_lower_string() user_in = UserCreate(email=username, password=password) user = crud.user.create(db_session, user_in=user_in) # noqa data = {"email": username, "password": password} r = requests.post( f"{server_api}{config.API_V1_STR}/users/", headers=superuser_token_headers, json=data, ) created_user = r.json() assert r.status_code == 400 assert "_id" not in created_user
async def insert_one(license: str, data: UserCreate, license_owner: bool): logging.info(">>> " + __name__ + ":insert_one") collection = get_collection(DOCUMENT_TYPE) fpwd = create_fpwd(data.username) hashed_password = get_password_hash(fpwd) model = UserSave(**data.dict(), license=license, hashed_password=hashed_password) props = fields_in_create(model) props["xfpwd"] = fpwd[::-1] try: rs = await collection.insert_one(props) if rs.inserted_id: user = await collection.find_one({"_id": rs.inserted_id}) return user except Exception as e: logging.info(e) raise_server_error(str(e))
def init_db(db_session): # Tables should be created with Alembic migrations # But if you don't want to use migrations, create # the tables un-commenting the next line Base.metadata.create_all(bind=engine) for user_fill in fill_data['users']: user = crud.user.get_by_email(db_session, email=user_fill['email']) if not user: user_in = UserCreate(email=user_fill['email'], password=user_fill['password'], full_name=user_fill['name'], is_superuser=user_fill['is_superuser'], can_report=user_fill['can_report'], relation=user_fill['relation']) user = crud.user.create(db_session, user_in=user_in) for sujeto_fill in fill_data['sujetos']: sujeto = crud.sujeto.get_by_name(db_session, name=sujeto_fill['name']) if not sujeto: sujeto_in = SujetoCreate( name=sujeto_fill['name'], gender=sujeto_fill['gender'], apodos=sujeto_fill['apodos'], birth=datetime.datetime.strptime(sujeto_fill['birth'], '%Y-%m-%d %H:%M:%S') if sujeto_fill['birth'] is not None else None, ) sujeto = crud.sujeto.create(db_session, sujeto_in=sujeto_in) for location_fill in fill_data['locations']: location = crud.location.get_by_name( db_session, location_name=location_fill['name']) if not location: location_in = LocationCreate(name=location_fill['name'], center=Coordinates( lat=location_fill['lat'], lng=location_fill['lng']), radius=location_fill['radius']) location = crud.location.create(db_session, location_in=location_in)
async def insert_one(data: UserCreate): logging.info(">>> " + __name__ + ":insert_one") # Check license valid = await is_license_valid(data.license) if not valid: raise_bad_request("License is not valid") collection = get_collection(DOCUMENT_TYPE) hashed_password = get_password_hash(data.password) model = UserInDB(**data.dict(), hashed_password=hashed_password) props = fields_in_create(model) try: rs = await collection.insert_one(props) if rs.inserted_id: user = await collection.find_one({"_id": rs.inserted_id}) return user except Exception as e: logging.info(e) raise_server_error(str(e))
async def register_new_user(self, *, new_user: UserCreate) -> UserInDB: # make sure email isn't already taken if await self.get_user_by_email(email=new_user.email): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail= "That email is already taken. Login with that email or register with another one." ) # make sure username isn't already taken if await self.get_user_by_username(username=new_user.username): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="That username is already taken. Please try another one." ) user_password_update = self.auth_service.create_salt_and_hashed_password( plaintext_password=new_user.password) new_user_params = new_user.copy(update=user_password_update.dict()) created_user = await self.db.fetch_one(query=REGISTER_NEW_USER_QUERY, values=new_user_params.dict()) return UserInDB(**created_user)
async def create_user(*, username: str = Body(...), password: str = Body(...), email: EmailStr = Body(None), full_name: str = Body(None)): """ Create new user. """ db = await get_database() user = await crud.user.get_user(db, username=username) if user: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="The user with this username already exists in the system.", ) user_in = UserCreate(username=username, password=password, email=email, full_name=full_name) user = await crud.user.create_in_db(db, user_in=user_in) return user_in
def create_user_open( *, db: Session = Depends(get_db), password: str = Body(...), email: EmailStr = Body(...), full_name: str = Body(None), ): """ Create new user without the need to be logged in. """ if not config.USERS_OPEN_REGISTRATION: raise HTTPException( status_code=403, detail="Open user resgistration is forbidden on this server", ) user = crud.user.get_by_email(db, email=email) if user: raise HTTPException( status_code=400, detail="The user with this username already exists in the system", ) user_in = UserCreate(password=password, email=email, full_name=full_name) user = crud.user.create(db, user_in=user_in) return user
async def create_user_and_get_token(db, client): # Create User and get token user_in = UserCreate(username=MOCK_USERNAME, password=MOCK_PASSWORD) res = await crud.user.create_in_db(db, user_in=user_in) headers = user_authentication_headers(client, MOCK_USERNAME, MOCK_PASSWORD) return headers
def create(): info = UserCreate(request.form.get('user_id')) return success({ 'user_id': info.id, })