async def test_like_post_save_like_in_db(id_, users):
await PostDAL.like(1, id_)
with create_session() as session:
post = session.query(Post).filter(Post.id == 1).one()
likes = post.likes
assert len(likes) == 1
assert likes[0].id == id_
def _save_tokens_to_db(user: OutUser, access_token: bytes,
refresh_token: bytes) -> None:
with create_session() as session:
user_from_db = session.query(User).filter(User.id == user.id).one()
user_from_db.refresh_token = refresh_token.decode()
user_from_db.access_token = access_token.decode()
session.add(user_from_db)
def _add_marked_users(ids: List[int], post_id: int) -> None:
with create_session() as session:
post = session.query(Post).filter(Post.id == post_id).first()
for id_ in ids:
user = session.query(User).filter(User.id == id_).first()
post.marked_users.append(user)
session.add(post)
def test_serialize_user(username):
with create_session() as session:
user = session.query(User).filter(User.id == 1).one()
res = serialize(user)
assert res.subscriptions == []
assert res.subscribers == []
assert res.id == 1
assert res.username == username
def test_process_add_marked_users_to_database(in_post, uuid):
in_post.marked_users_ids = [2, 3]
process_image(1, in_post, uuid)
with create_session() as session:
post = session.query(Post).filter(Post.id == 1).first()
marked_users = post.marked_users
assert len(marked_users) == 2
assert list(map(lambda user: user.id, marked_users)) == [2, 3]
async def test_subscribe_on_user_change_data_on_db(out_user_first):
await UsersDataAccessLayer.subscribe(1, 2)
with create_session() as session:
user = session.query(User).filter(User.id == 1).one()
subscriptions = user.subscriptions
assert len(subscriptions) == 1
user2: User = session.query(User).filter(User.id == 2).one()
assert user2 in subscriptions
subscribers = user2.subscribers
assert len(subscribers) == 1
assert user in subscribers
def _authenticate_user(username: str, password: str) -> Awaitable[OutUser]:
message = Message.INCORRECT_USERNAME_OR_PASSWORD.value
with create_session() as session:
user: Optional[User] = session.query(User).filter(
User.username == username).first()
user = deepcopy(user)
if user is None:
raise DALError(HTTPStatus.UNAUTHORIZED.value, message)
if _is_password_correct(password, user.password_hash):
return OutUser.from_orm(user) # type: ignore
raise DALError(HTTPStatus.UNAUTHORIZED.value, message)
async def like(post_id: int, user_id_who_likes: int) -> List[OutUser]:
with create_session() as session:
post = await PostDAL._get_post(post_id, session)
likes = post.likes
user = await PostDAL._get_user(user_id_who_likes, session)
if PostDAL._is_user_has_like(likes, user):
raise DALError(
HTTPStatus.BAD_REQUEST.value,
Message.USER_HAS_ALREADY_LIKE_THIS_POST.value,
)
likes.append(user)
return [OutUser.from_orm(user) for user in likes]
def test_process_add_post_in_database(in_post, uuid, mocked_datetime):
user_id = 1
time = datetime.utcnow()
mocked_datetime.utcnow.return_value = time
process_image(user_id, in_post, uuid)
with create_session() as session:
post = session.query(Post).filter(Post.id == 1).first()
assert post
assert post.user_id == user_id
assert post.location == in_post.location
assert post.description == in_post.description
assert post.created_at == time
async def remove_like(post_id: int,
user_id_who_wants_delete_like: int) -> None:
with create_session() as session:
post = await PostDAL._get_post(post_id, session)
user = await PostDAL._get_user(user_id_who_wants_delete_like,
session)
likes = post.likes
if not PostDAL._is_user_has_like(likes, user):
raise DALError(
HTTPStatus.NOT_FOUND.value,
Message.USER_DID_NOT_LIKE_THIS_POST.value,
)
likes.remove(user)
def _add_post_to_db(
user_id: int, image_path: str, description: str, location: Optional[str]
) -> int:
with create_session() as session:
post = Post(
user_id=user_id,
image_path=image_path,
description=description,
location=location,
created_at=datetime.utcnow(),
)
session.add(post)
session.flush()
return post.id
async def get_post(post_id: int) -> PostWithImage:
with create_session() as session:
post = await PostDAL._get_post(post_id, session)
try:
image: Base64 = (await
storage_client.get_image_from_storage_async(
post.image_path)).image
except StorageError:
raise DALError(
HTTPStatus.NOT_FOUND.value,
Message.IMAGE_DOES_NOT_EXISTS_ON_STORAGE.value,
)
serialized_post: Post = serialize(post) # type: ignore
return PostWithImage(**serialized_post.dict(), image=image)
async def get_posts(user_id: int) -> List[PostWithImage]:
with create_session() as session:
user = session.query(User).filter(User.id == user_id).first()
if not user:
raise DALError(HTTPStatus.NOT_FOUND.value,
Message.USER_DOES_NOT_EXISTS.value)
posts = user.posts
if not posts:
raise DALError(HTTPStatus.NOT_FOUND.value,
Message.POSTS_DO_NOT_EXIST.value)
try:
images: List[
ImageWithPath] = await storage_client.get_all_user_images(
user_id)
except StorageError as e:
raise DALError(HTTPStatus.BAD_REQUEST.value, e)
return join_posts_with_images(posts, images)
async def test_remove_like_deletes_it_in_db_with_multiple_likes_case():
await PostDAL.like(1, 2)
await PostDAL.remove_like(1, 1)
with create_session() as session:
post = session.query(Post).filter(Post.id == 1).one()
assert len(post.likes) == 1
def test_serialize_user_with_subscriber(username, out_user_first):
with create_session() as session:
user = session.query(User).filter(User.id == 2).one()
res = serialize(user)
assert res.subscribers == [out_user_first]
async def _add_2_users(in_user):
with create_session() as session:
for i in range(2):
in_user.username = str(i)
await UsersDataAccessLayer.add_user(in_user)
def test_serialize_user_with_subscriptions(username, out_user_second):
with create_session() as session:
user = session.query(User).filter(User.id == 1).one()
res = serialize(user)
assert res.subscriptions == [out_user_second]
async def test_add_user_function_encrypts_password(in_user):
with create_session() as s:
user = s.query(User).filter(User.id == 1).first()
assert user.password_hash == get_password_hash(in_user.password)
async def test_add_new_user_adds_data_to_database(in_user):
with create_session() as s:
user = s.query(User).filter(User.id == 1).first()
assert user
assert user.username == in_user.username
async def test_get_tokens_save_tokens_to_db(username, password, tokens):
with create_session() as session:
user = session.query(User).filter(User.username == username).first()
assert user.access_token == tokens.access_token.decode()
assert user.refresh_token == tokens.refresh_token.decode()
async def test_refresh_tokens_saves_new_tokens_pair_to_db(username, password, tokens):
new_tokens = await refresh_tokens(tokens.refresh_token.decode())
with create_session() as session:
user = session.query(User).filter(User.username == username).first()
assert user.refresh_token == new_tokens.refresh_token.decode()
assert user.access_token == new_tokens.access_token.decode()