def delete_review(
self,
input_dto: DeleteReviewInputDto,
drink_application_service: DrinkApplicationService,
) -> Union[DeleteReviewOutputDto, FailedOutputDto]:
try:
review_id = ReviewId.from_str(input_dto.review_id)
review = self._review_repository.find_by_review_id(review_id)
if review is None:
return FailedOutputDto.build_resource_not_found_error(
f"{str(input_dto.review_id)}의 리뷰를 찾을 수 없습니다.")
self._review_repository.delete_by_review_id(review_id)
drinks_input_dto = DeleteDrinkReviewInputDto(
drink_id=str(review.drink_id), drink_rating=int(review.rating))
drink_delete_review_output_dto = drink_application_service.delete_drink_review(
input_dto=drinks_input_dto)
if not drink_delete_review_output_dto.status:
return drink_delete_review_output_dto
return DeleteReviewOutputDto()
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(
message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def delete_drink(self, input_dto: DeleteDrinkInputDto) -> Union[DeleteDrinkOutputDto, FailedOutputDto]:
try:
drink_id = DrinkId.from_str(input_dto.drink_id)
if self._drink_repository.find_by_drink_id(drink_id) is None:
return FailedOutputDto.build_resource_not_found_error(f"{str(drink_id)}의 술을 찾을 수 없습니다.")
self._drink_repository.delete_by_drink_id(drink_id)
return DeleteDrinkOutputDto()
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def delete_user(
self, input_dto: DeleteUserInputDto
) -> Union[DeleteUserOutputDto, FailedOutputDto]:
try:
user_id = UserId(value=input_dto.user_id)
self._user_repository.delete_by_user_id(user_id)
return DeleteUserOutputDto()
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(
message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def test_get_users_fail(user_application_service_mock, client, app):
user_application_service_mock.find_user.return_value = FailedOutputDto.build_resource_not_found_error(
)
with app.container.user_application_service.override(
user_application_service_mock):
response = client.get("/users/heumsi")
assert response.status_code == 404
assert response.json() == {
"error_type": "Resource Not Found Error",
"message": "",
}
def test_login_fail_with_wrong_id(user_repository_mock):
wrong_user_id = "joon"
user_repository_mock.find_by_user_id.side_effect = ResourceNotFoundError(
f"{wrong_user_id}의 유저를 찾지 못했습니다.")
user_application_service = UserApplicationService(
user_repository=user_repository_mock)
input_dto = LoginInputDto(user_id=wrong_user_id, password="******")
actual = user_application_service.login(input_dto)
expected = FailedOutputDto.build_resource_not_found_error(
message=f"{str(input_dto.user_id)}의 유저를 찾지 못했습니다.")
assert actual == expected
def add_drink_wish(self, input_dto: AddDrinkWishInputDto) -> Union[AddDrinkWishOutputDto, FailedOutputDto]:
try:
drink = self._drink_repository.find_by_drink_id(DrinkId.from_str(input_dto.drink_id))
drink.add_wish()
self._drink_repository.update(drink)
return AddDrinkWishOutputDto()
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def find_drink(self, input_dto: FindDrinkInputDto) -> Union[FindDrinkOutputDto, FailedOutputDto]:
try:
drink = self._drink_repository.find_by_drink_id(drink_id=DrinkId.from_str(input_dto.drink_id))
if drink is None:
return FailedOutputDto.build_resource_not_found_error(
message=f"{str(input_dto.drink_id)}의 술을 찾을 수 없습니다."
)
return FindDrinkOutputDto(
drink_id=str(drink.id),
drink_name=drink.name,
drink_image_url=drink.image_url,
drink_type=drink.type.value,
avg_rating=float(drink.avg_rating),
num_of_reviews=drink.num_of_reviews,
num_of_wish=drink.num_of_wish,
)
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def update_drink_review(
self, input_dto: UpdateDrinkReviewInputDto
) -> Union[UpdateDrinkReviewOutputDto, FailedOutputDto]:
try:
drink = self._drink_repository.find_by_drink_id(DrinkId.from_str(input_dto.drink_id))
if drink is None:
return FailedOutputDto.build_resource_not_found_error(
message=f"{str(input_dto.drink_id)}의 술을 찾을 수 없습니다."
)
drink.update_rating(
old_rating=input_dto.old_drink_rating,
new_rating=input_dto.new_drink_rating,
)
self._drink_repository.update(drink)
return UpdateDrinkReviewOutputDto()
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def update_drink(self, input_dto: UpdateDrinkInputDto) -> Union[UpdateDrinkOutputDto, FailedOutputDto]:
try:
drink_id = DrinkId.from_str(input_dto.drink_id)
if self._drink_repository.find_by_drink_id(drink_id) is None:
return FailedOutputDto.build_resource_not_found_error(f"{str(drink_id)}의 술을 찾을 수 없습니다.")
drink = Drink(
id=drink_id,
name=input_dto.drink_name,
image_url=input_dto.drink_image_url,
type=input_dto.drink_type,
avg_rating=DrinkRating(value=input_dto.avg_rating),
num_of_reviews=input_dto.num_of_reviews,
num_of_wish=input_dto.num_of_wish,
)
self._drink_repository.update(drink)
return UpdateDrinkOutputDto()
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def test_get_token_fail(jwt_secret_key, jwt_algorithm):
user_application_service_mock = mock.Mock(spec=UserApplicationService)
user_application_service_mock.login.return_value = FailedOutputDto.build_resource_not_found_error(
"heumsi의 유저를 찾지 못했습니다."
)
auth_application_service = AuthApplicationService(
user_application_service=user_application_service_mock,
jwt_secret_key=jwt_secret_key,
jwt_algorithm="jwt_algorithm",
)
input_dto = GetTokenInputDto(user_id="heumsi", password="******")
actual = auth_application_service.get_token(input_dto=input_dto)
expected = FailedOutputDto.build_resource_error("heumsi의 유저를 찾지 못했습니다.")
assert actual == expected
def login(
self, input_dto: LoginInputDto
) -> Union[LoginOutputDto, FailedOutputDto]:
try:
user_id = UserId(value=input_dto.user_id)
user = self._user_repository.find_by_user_id(user_id=user_id)
if not self._verify_password(input_dto.password, user.password):
return FailedOutputDto.build_unauthorized_error(
f"잘못된 비밀번호 입니다.")
return LoginOutputDto()
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(
message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def delete_drink_review(
self, input_dto: DeleteDrinkReviewInputDto
) -> Union[DeleteDrinkReviewOutputDto, FailedOutputDto]:
try:
drink = self._drink_repository.find_by_drink_id(DrinkId.from_str(input_dto.drink_id))
drink.delete_rating(input_dto.drink_rating)
self._drink_repository.update(drink)
return DeleteDrinkReviewOutputDto()
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def test_get_token_fail(auth_application_service_mock, app, client):
auth_application_service_mock.get_token.return_value = FailedOutputDto.build_resource_not_found_error(
"heumsi의 유저를 찾지 못했습니다.")
with app.container.auth_application_service.override(
auth_application_service_mock):
response = client.post(
"/auth/token",
json=GetTokenJsonRequest(user_id="heumsi", password="******").dict(),
)
assert response.status_code == 404
assert response.json() == {
"error_type": "Resource Not Found Error",
"message": "heumsi의 유저를 찾지 못했습니다.",
}
def update_user(
self, input_dto: UpdateUserInputDto
) -> Union[UpdateUserOutputDto, FailedOutputDto]:
try:
user = User(
id=UserId(value=input_dto.user_id),
name=UserName(value=input_dto.user_name),
description=input_dto.description,
password=input_dto.password,
)
self._user_repository.update(user)
return UpdateUserOutputDto()
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(
message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def find_user(
self, input_dto: FindUserInputDto
) -> Union[FindUserOutputDto, FailedOutputDto]:
try:
user = self._user_repository.find_by_user_id(user_id=UserId(
value=input_dto.user_id))
return FindUserOutputDto(
user_id=str(user.id),
user_name=str(user.name),
description=user.description,
image_url=user.image_url,
)
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(
message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def test_delete_users_fail(user_application_service_mock, client, app):
user_application_service_mock.delete_user.return_value = FailedOutputDto.build_resource_not_found_error(
message="heumsi의 유저를 찾지 못했습니다.")
with app.container.user_application_service.override(
user_application_service_mock):
response = client.delete(
"/users",
headers={
"access-token":
"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiaGV1bXNpIn0.OuFWvZ07CwSzR1j7I-wxFHweVb6sB8_U2LezYL7nz3I"
},
)
assert response.status_code == 404
assert response.json() == {
"error_type": "Resource Not Found Error",
"message": "heumsi의 유저를 찾지 못했습니다.",
}
def find_review(
self, input_dto: FindReviewInputDto
) -> Union[FindReviewOutputDto, FailedOutputDto]:
try:
review_id = ReviewId.from_str(input_dto.review_id)
review = self._review_repository.find_by_review_id(review_id)
return FindReviewOutputDto(
review_id=str(review.id),
drink_id=str(review.drink_id),
user_id=str(review.user_id),
rating=int(review.rating),
comment=review.comment,
created_at=review.created_at,
updated_at=review.updated_at,
)
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(
message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def delete_wish(
self,
input_dto: DeleteWishInputDto,
drink_application_service: DrinkApplicationService,
) -> Union[DeleteWishOutputDto, FailedOutputDto]:
try:
wish = self._wish_repository.delete_by_wish_id(
WishId.from_str(input_dto.wish_id))
delete_drink_wish_input_dto = DeleteDrinkWishInputDto(
drink_id=str(wish.drink_id))
delete_drink_wish_output_dto = drink_application_service.delete_drink_wish(
input_dto=delete_drink_wish_input_dto)
if not delete_drink_wish_output_dto.status:
return delete_drink_wish_output_dto
return DeleteWishOutputDto()
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(
message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def test_get_review(client, app):
application_service_mock = mock.Mock(spec=ReviewApplicationService)
application_service_mock.find_review.return_value = FailedOutputDto.build_resource_not_found_error(
)
# valid request but no resource
with app.container.review_application_service.override(
application_service_mock):
response = client.get("/reviews/123-123-123")
assert response.status_code == 404
assert response.json() == {
"error_type": "Resource Not Found Error",
"message": "",
}
# valid request
application_service_mock.find_review.return_value = FindReviewOutputDto(
review_id="review_id_uuid",
drink_id="drink_id_uuid",
user_id="user_id_uuid",
rating=4,
comment="tastes good",
created_at=737373737.6,
updated_at=737373737.6,
)
with app.container.review_application_service.override(
application_service_mock):
response = client.get("/reviews/review_id_uuid")
assert response.status_code == 200
assert response.json() == {
"review_id": "review_id_uuid",
"drink_id": "drink_id_uuid",
"user_id": "user_id_uuid",
"rating": 4,
"comment": "tastes good",
"created_at": 737373737.6,
"updated_at": 737373737.6,
}
def update_review(
self,
input_dto: UpdateReviewInputDto,
drink_application_service: DrinkApplicationService,
) -> Union[UpdateReviewOutputDto, FailedOutputDto]:
try:
review_id = ReviewId.from_str(input_dto.review_id)
old_review = self._review_repository.find_by_review_id(review_id)
old_rating = int(old_review.rating)
new_review = Review(
id=old_review.id,
drink_id=old_review.drink_id,
user_id=old_review.user_id,
rating=ReviewRating(value=input_dto.rating),
comment=input_dto.comment,
created_at=old_review.created_at,
updated_at=time.time(),
)
self._review_repository.update(new_review)
drinks_input_dto = UpdateDrinkReviewInputDto(
drink_id=str(new_review.drink_id),
old_drink_rating=old_rating,
new_drink_rating=input_dto.rating,
)
drink_update_review_output_dto = drink_application_service.update_drink_review(
input_dto=drinks_input_dto)
if not drink_update_review_output_dto.status:
return drink_update_review_output_dto
return UpdateReviewOutputDto()
except ResourceNotFoundError as e:
return FailedOutputDto.build_resource_not_found_error(
message=str(e))
except Exception as e:
return FailedOutputDto.build_system_error(message=str(e))
def test_update_review(client, app):
application_service_mock = mock.Mock(ReviewApplicationService)
auth_service_mock = mock.Mock(AuthApplicationService)
# unauthorized token
auth_service_mock.get_token_data.return_value = FailedOutputDto.build_unauthorized_error(
)
application_service_mock.create_review.return_value = CreateReviewOutputDto(
review_id="review_id_uuid",
drink_id="drink_id_uuid",
user_id="user_id_uuid",
rating=4,
comment="review comment",
created_at=123.123,
updated_at=123.123,
)
with app.container.review_application_service.override(
application_service_mock):
with app.container.auth_application_service.override(
auth_service_mock):
response = client.put(
"/reviews",
headers={
"access-token":
"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiaGV1bXNpIn0.OuFWvZ07CwSzR1j7I-wxFHweVb6sB8_U2LezYL7nz3I"
},
json=UpdateReviewJsonRequest(
review_id="review_id_uuid",
rating=4,
comment="updated review comment",
).dict(),
)
assert response.status_code == 401
assert response.json() == {
"error_type": "Unauthorized Error",
"message": "",
}
# invalid request
application_service_mock.create_review.return_value = FailedOutputDto.build_resource_not_found_error(
)
with app.container.review_application_service.override(
application_service_mock):
response = client.post(
"/reviews",
headers={
"access-token":
"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiaGV1bXNpIn0.OuFWvZ07CwSzR1j7I-wxFHweVb6sB8_U2LezYL7nz3I"
},
json=CreateReviewJsonRequest(
drink_id="drink_id_uuid",
rating=4,
comment="review comment",
).dict(),
)
assert response.status_code == 404
assert response.json() == {
"error_type": "Resource Not Found Error",
"message": "",
}
# valid request
application_service_mock.create_review.return_value = CreateReviewOutputDto(
review_id="review_id_uuid",
drink_id="drink_id_uuid",
user_id="user_id_uuid",
rating=4,
comment="review comment",
created_at=123.123,
updated_at=123.123,
)
with app.container.review_application_service.override(
application_service_mock):
response = client.post(
"/reviews",
headers={
"access-token":
"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiaGV1bXNpIn0.OuFWvZ07CwSzR1j7I-wxFHweVb6sB8_U2LezYL7nz3I"
},
json=CreateReviewJsonRequest(
drink_id="drink_id_uuid",
rating=4,
comment="review comment",
).dict(),
)
assert response.status_code == 201
assert response.json() == {
"review_id": "review_id_uuid",
"drink_id": "drink_id_uuid",
"rating": 4,
"comment": "review comment",
"created_at": 123.123,
"updated_at": 123.123,
}
