def startup_event():
Base.metadata.create_all(bind=engine)
db: Session = SessionLocal()
user = crud.get_user_by_email(db, settings.super_user_email)
if not user:
user_in = users_schemas.UserCreate(
email=settings.super_user_email, password=settings.super_user_password
)
logging.info("Creating superuser")
crud.create_user(db, user_in)
db.close()
def db():
user.Base.metadata.create_all(bind=engine)
admin_user = UserCreateRequest(
full_name="Chosen One",
email="*****@*****.**",
username=settings.ADMIN_USERNAME,
password=settings.ADMIN_PASSWORD,
admin=True,
)
crud.create_user(SessionLocal(), admin_user)
yield SessionLocal()
drop_database(engine.url)
def test_can_get_all_users(db, cleanup):
email = "*****@*****.**"
password = "******"
user_in = UserCreate(email=email, password=password)
user = crud.create_user(db, user=user_in)
email2 = "*****@*****.**"
password = "******"
user_in2 = UserCreate(email=email2, password=password)
user2 = crud.create_user(db, user=user_in2)
response = client.get("/users/")
assert response.status_code == 200
resp = response.json()
assert resp[0]['email'] == '*****@*****.**'
assert resp[1]['email'] == '*****@*****.**'
assert len(resp) == 2
def user_token_header(db: SessionLocal()):
user = UserCreateRequest(
full_name=faker.name(),
email=faker.email(),
username=faker.word(),
password=faker.md5(),
admin=False,
)
if not crud.get_user_by_username(db, username=user.username):
crud.create_user(db, user)
user_token = create_jwt_token(user.username)
headers = {"Authorization": f"Bearer {user_token}"}
return headers
def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
db_user = crud.get_user_by_email(db, email=user.email)
if db_user:
raise HTTPException(status_code=400, detail="Email already registered")
created_user = crud.create_user(db=db, user=user)
return created_user
def signup(user_data: schemas.UserCreate, db: Session = Depends(get_db)):
"""add new user"""
user = crud.get_user_by_email(db, user_data.email)
if user:
raise HTTPException(status_code=409, detail="Email already exists.")
new_user = crud.create_user(db, user_data)
return new_user
def test_user_image_has_default_value(db, cleanup):
email = "*****@*****.**"
password = "******"
username = "******"
user_in = UserCreate(email=email, password=password, username=username)
user = crud.create_user(db, user=user_in)
assert user.image == ''
def register(user: types.User = Body(..., embed=True),
database: Session = Depends(get_database)):
exist_user = crud.get_user_by_phone_number(database, user.phone_number)
if exist_user:
return {'text': 'user already exists!', 'user': exist_user}
db_user = crud.create_user(database, user)
exist_user = crud.get_user_by_phone_number(database, user.phone_number)
return {'text': 'user created successfully!', 'user': exist_user}
def test_can_create_a_favorite_with_no_existing_market(db, cleanup):
market_id = 123
email = "*****@*****.**"
password = "******"
user_in = UserCreate(email=email, password=password)
user = crud.create_user(db, user=user_in)
response = client.post(f"/users/{user.id}/favorites",
json={"fmid": market_id})
assert response.status_code == 200
def create_user(user: app.schemas.users.UserCreate,
db: Session = Depends(deps.get_db)):
"""
Create a new user. Requires superuser permissions.
"""
db_user = crud.get_user_by_email(db, email=user.email)
if db_user:
raise HTTPException(status_code=400, detail="Email already registered")
return crud.create_user(db=db, user=user)
async def create_user(user: schemas.UserBase = Body(..., embed=True)):
db_user = crud.get_user_by_email(email=user.email)
db_user1 = crud.get_user_by_username(username=user.username)
if db_user:
raise HTTPException(status_code=400, detail="Cet Email existe deja")
if db_user1:
raise HTTPException(status_code=400,
detail="Ce nom d'utilisateur existe deja")
return crud.create_user(user=user)
def test_can_get_a_single_user(db, cleanup):
email = "*****@*****.**"
password = "******"
user_in = UserCreate(email=email, password=password)
user = crud.create_user(db, user=user_in)
response = client.get("/users/1")
assert response.status_code == 200
resp = response.json()
assert resp['email'] == '*****@*****.**'
assert resp['id'] == 1
assert resp['favorites'] == []
def test_create_user(db: Session):
profile1 = faker.simple_profile()
user_request = UserCreateRequest(
full_name=profile1["name"],
username=profile1["username"],
email=profile1["mail"],
password=faker.md5(),
)
user = crud.create_user(db, user_request)
assert user
assert user.username == user_request.username
def seed_db(db: Session):
agnes = create_user(db, UserBase(email="*****@*****.**"))
brynn = create_user(db, UserBase(email="*****@*****.**"))
carli = create_user(db, UserBase(email="*****@*****.**"))
create_bear(db, BearBase(name="Baloo", species=Species.sloth), agnes)
create_bear(db, BearBase(name="Boo-Boo", species=Species.brown), brynn)
create_bear(db, BearBase(name="Cindy", species=Species.brown), carli)
create_bear(db, BearBase(name="Hei Bai", species=Species.panda), agnes)
create_bear(db, BearBase(name="Honey", species=Species.sun), brynn)
create_bear(db, BearBase(name="Jake", species=Species.polar), carli)
create_bear(db, BearBase(name="Kit Cloudkicker", species=Species.brown),
agnes)
create_bear(db, BearBase(name="Mor'du", species=Species.black), brynn)
create_bear(db, BearBase(name="Paddington", species=Species.spectacled),
carli)
create_bear(db, BearBase(name="Panny", species=Species.panda), agnes)
create_bear(db, BearBase(name="PapaPanda", species=Species.panda), brynn)
create_bear(db, BearBase(name="Po", species=Species.panda), carli)
create_bear(db, BearBase(name="Smokey", species=Species.black), agnes)
create_bear(db, BearBase(name="Yogi", species=Species.brown), brynn)
def test_get_user_by_email(db: Session):
profile3 = faker.simple_profile()
user_request = UserCreateRequest(
full_name=profile3["name"],
username=profile3["username"],
email=profile3["mail"],
password=faker.md5(),
)
user_in_db = crud.create_user(db, user_request)
result = crud.get_user_by_email(db, user_in_db.email)
assert result
assert user_request.email == result.email
async def register_user(
register_request: RegisterRequest, db: Session = Depends(get_db)
):
"""Register a new user.
The user will have to verify their account via /auth/verify."""
db_user = crud.get_user_by_username(db, username=register_request.username)
if db_user:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="A user with this username is already registered",
)
return crud.create_user(db=db, user=register_request)
def user_seeder(db: Session):
user.Base.metadata.create_all(bind=engine)
one = UserCreateRequest(
full_name="Chosen One",
email="*****@*****.**",
username=settings.ADMIN_USERNAME,
password=settings.ADMIN_PASSWORD,
admin=True,
)
two = UserCreateRequest(
full_name="Morpheus",
email="*****@*****.**",
username="******",
password=settings.ADMIN_PASSWORD,
admin=False,
)
three = UserCreateRequest(
full_name="Tank",
email="*****@*****.**",
username="******",
password=settings.ADMIN_PASSWORD,
admin=False,
)
one_in_db = crud.get_user_by_username(db, username=one.username)
two_in_db = crud.get_user_by_username(db, username=two.username)
three_in_db = crud.get_user_by_username(db, username=three.username)
if not one_in_db:
crud.create_user(db, one)
if not two_in_db:
crud.create_user(db, two)
if not three_in_db:
crud.create_user(db, three)
def test_create_user(db, cleanup):
email = "*****@*****.**"
password = "******"
username = "******"
image = "12674.jpg"
user_in = UserCreate(email=email,
password=password,
username=username,
image=image)
user = crud.create_user(db, user=user_in)
assert user.email == email
assert user.username == username
assert user.image == image
def test_it_can_get_all_user_favorites(db, cleanup):
market_id = 123456
market_in = MarketCreate(market_id=market_id)
market = crud.create_market(db, market=market_in)
email = "*****@*****.**"
password = "******"
user_in = UserCreate(email=email, password=password)
user = crud.create_user(db, user=user_in)
client.post(f"/users/{user.id}/favorites", json={"fmid": market_id})
response = client.get(f"/users/{user.id}/favorites")
assert response.status_code == 200
resp = response.json()
assert resp['favorites'] == [{'market_id': 123456, 'id': 1}]
def create_users():
"""
create test users:
- username: admin, password: admin, isadmin: "true"
- username: user2, password: user2pass, isadmin: "false"
"""
if not crud.get_user(db=database.SessionLocal(),
username="******") and not crud.get_admins(
db=database.SessionLocal()):
user = schemas.UserCreate(**{
"username": "******",
"password": "******",
"isadmin": "true"
})
crud.create_user(db=database.SessionLocal(), user=user)
if not crud.get_user(db=database.SessionLocal(), username="******"):
user = schemas.UserCreate(**{
"username": "******",
"password": "******",
"isadmin": "false"
})
crud.create_user(db=database.SessionLocal(), user=user)
def test_it_cant_create_a_favorite_if_user_already_has_one(db, cleanup):
market_id = 123
email = "*****@*****.**"
password = "******"
user_in = UserCreate(email=email, password=password)
user = crud.create_user(db, user=user_in)
market_in = MarketCreate(market_id=market_id)
market = crud.create_market(db, market=market_in)
favorite_in = FavoriteCreate(user_id=user.id, market_id=market.id)
favorite = crud.favorite_market(db, favorite=favorite_in)
response = client.post(f"/users/{user.id}/favorites",
json={"fmid": market_id})
assert response.status_code == 400
resp = response.json()
assert resp['detail'] == 'That market is already favorited!'
def test_it_can_login_a_user(db, cleanup):
email = "*****@*****.**"
password = "******"
user_in = UserCreate(email=email, password=password)
user = crud.create_user(db, user=user_in)
response = client.post("/login/token",
data={
"username": email,
"password": password
})
resp = response.json()
assert response.status_code == 200
assert "access_token" in resp
assert resp["access_token"]
async def create_user(
user_request: UserCreateRequest,
db: Session = Depends(get_db),
token: str = Depends(oauth2_scheme),
):
"""Create a new user"""
user = get_user_by_token(db, token)
if not user.admin:
raise HTTPException(status_code=403, detail="Forbidden")
user_by_email = crud.get_user_by_email(db, user_request.email)
user_by_username = crud.get_user_by_username(db, user_request.username)
if user_by_email or user_by_username:
raise HTTPException(status_code=400, detail="The user already exists.")
return crud.create_user(db, user_request)
def test_access_token_works(db, cleanup):
email = "*****@*****.**"
password = "******"
user_in = UserCreate(email=email, password=password)
user = crud.create_user(db, user=user_in)
response = client.post("/login/token",
data={
"username": email,
"password": password
})
token = response.json()
a_token = token["access_token"]
headers = {"Authorization": f"Bearer {a_token}"}
response2 = client.post("/login/token_check", headers=headers)
assert response2.status_code == 200
def create_User(user: SignupUser, db: Session = Depends(get_db)):
if (findByEmail(user.email, db) != None):
raise HTTPException(status_code=status.HTTP_406_NOT_ACCEPTABLE,
detail="Email already taken")
if (findByusername(user.username, db) != None):
raise HTTPException(status_code=status.HTTP_406_NOT_ACCEPTABLE,
detail="Username already taken")
if (NotConfirmPassword(user.password, user.confirmPassword)):
raise HTTPException(
status_code=status.HTTP_406_NOT_ACCEPTABLE,
detail="confirm Password doesnot match with Password")
dbuser = create_user(db, user)
return {
"success": "OK",
"user": dbuser
} # Testing er jono I have to remove this
def test_it_can_update_a_users_password(db, cleanup):
email = "*****@*****.**"
password = "******"
user_in = UserCreate(email=email, password=password)
user = crud.create_user(db, user=user_in)
update_response = client.put(f"/users/{user.id}",
json={"password": "******"})
assert update_response.status_code == 200
response = client.post("/login/token",
data={
"username": email,
"password": '******'
})
token = response.json()
assert response.status_code == 200
assert "access_token" in token
assert token["access_token"]
def test_create_user_favorites(db, cleanup):
email = "*****@*****.**"
password = "******"
market_id = 1
market_id2 = 2
user_in = UserCreate(email=email, password=password)
market_in = MarketCreate(market_id=market_id)
market_in2 = MarketCreate(market_id=market_id2)
user = crud.create_user(db, user=user_in)
market = crud.create_market(db, market=market_in)
market2 = crud.create_market(db, market=market_in2)
favorite_in = FavoriteCreate(user_id=user.id, market_id=market.id)
favorite_in2 = FavoriteCreate(user_id=user.id, market_id=market2.id)
favorite = crud.favorite_market(db, favorite=favorite_in)
favorite2 = crud.favorite_market(db, favorite=favorite_in2)
assert favorite.user_id == user.id
assert favorite.market_id == market.id
assert len(user.favorites) == 2
assert user.favorites[0] == market
assert user.favorites[1] == market2
def test_it_can_delete_user_favorites(db, cleanup):
market_id = 123456
market_in = MarketCreate(market_id=market_id)
market = crud.create_market(db, market=market_in)
email = "*****@*****.**"
password = "******"
user_in = UserCreate(email=email, password=password)
user = crud.create_user(db, user=user_in)
client.post(f"/users/{user.id}/favorites", json={"fmid": market_id})
response = client.get(f"/users/{user.id}")
user_resp = response.json()
assert len(user_resp['favorites']) == 1
response2 = client.delete(f"/users/{user.id}/favorites",
json={"fmid": market_id})
user_resp2 = response2.json()
assert response2.status_code == 200
assert user_resp2['favorites'] == []
assert len(user_resp2['favorites']) == 0
def test_it_can_update_a_user(db, cleanup):
email = "*****@*****.**"
password = "******"
user_in = UserCreate(email=email, password=password)
user = crud.create_user(db, user=user_in)
update_response = client.put(f"/users/{user.id}",
json={"username": "******"})
assert update_response.status_code == 200
resp = update_response.json()
assert resp['username'] == 'chunky_lover'
update_response2 = client.put(f"/users/{user.id}",
json={
"email": "*****@*****.**",
"image": "dancing_cat.jpg"
})
assert update_response2.status_code == 200
resp2 = update_response2.json()
assert resp2['image'] == "dancing_cat.jpg"
assert resp2['email'] == '*****@*****.**'
async def create_user(user: UserCreate, db: Session = Depends(get_db)):
#TODO: test if user exists
return crud.create_user(db, user)
