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,
})
