added some mappers

src/main/java/com/zufar/icedlatte/favorite/converter/FavoriteListDtoConverter.java

@@ -6,50 +6,48 @@
 import com.zufar.icedlatte.favorite.entity.FavoriteListEntity;
 import com.zufar.icedlatte.openapi.dto.ProductInfoDto;
 import com.zufar.icedlatte.product.entity.ProductInfo;
-import org.mapstruct.InjectionStrategy;
-import org.mapstruct.Mapper;
-import org.mapstruct.MappingConstants;
-import org.mapstruct.ReportingPolicy;
+import com.zufar.icedlatte.user.entity.UserEntity;
+import org.mapstruct.*;
 
-import java.util.HashSet;
-import java.util.Set;
+import java.util.Optional;
 import java.util.UUID;
 
 @Mapper(componentModel = MappingConstants.ComponentModel.SPRING,
         uses = FavoriteItemDtoConverter.class, unmappedTargetPolicy = ReportingPolicy.IGNORE, injectionStrategy = InjectionStrategy.FIELD)
 public interface FavoriteListDtoConverter {
 
-    default FavoriteListDto toDto(final FavoriteListEntity favoriteListEntity) {
-        UUID id = favoriteListEntity.getId();
-        UUID userId = favoriteListEntity.getUser().getId();
-        Set<FavoriteItemDto> favoriteItemsDto = new HashSet<>();
-
-        for (FavoriteItemEntity itemEntity : favoriteListEntity.getFavoriteItems()) {
-            UUID favoriteItemEntityId = itemEntity.getId();
-            ProductInfo productInfo = itemEntity.getProductInfo();
-
-            ProductInfoDto productInfoDto = convertProductInfoDto(productInfo);
+    @Mapping(target = "id", source = "id")
+    @Mapping(target = "userId", source = "user", qualifiedByName = "toUserId")
+    @Mapping(target = "updatedAt", source = "updatedAt")
+    @Mapping(target = "favoriteItems", source = "favoriteItems", qualifiedByName = "mapFavoriteItems")
+    FavoriteListDto toDto(final FavoriteListEntity favoriteListEntity);
+
+    @Mapping(target = "id", source = "productId")
+    @Mapping(target = "name", source = "name")
+    @Mapping(target = "description", source = "description")
+    @Mapping(target = "price", source = "price")
+    @Mapping(target = "quantity", source = "quantity")
+    @Mapping(target = "active", source = "active")
+    @Mapping(target = "averageRating", source = "averageRating")
+    @Mapping(target = "reviewsCount", source = "reviewsCount")
+    @Mapping(target = "brandName", source = "brandName")
+    @Mapping(target = "sellerName", source = "sellerName")
+    ProductInfoDto convertProductInfoDto(ProductInfo productInfo);
+
+    @Named("toUserId")
+    default UUID convertToUserId(UserEntity user) {
+        Optional<UserEntity> userOptional = Optional.ofNullable(user);
+        Optional<UUID> userIdOptional = userOptional.map(UserEntity::getId);
+        return userIdOptional.orElse(null);
+    }
 
-            FavoriteItemDto favoriteItemDto = new FavoriteItemDto(favoriteItemEntityId, productInfoDto);
-            favoriteItemsDto.add(favoriteItemDto);
-        }
+    @Named("mapFavoriteItems")
+    default FavoriteItemDto toFavoriteItemDto(FavoriteItemEntity itemEntity) {
+        UUID favoriteItemEntityId = itemEntity.getId();
+        ProductInfo productInfo = itemEntity.getProductInfo();
 
-        return new FavoriteListDto(id, userId, favoriteItemsDto, favoriteListEntity.getUpdatedAt());
-    }
+        ProductInfoDto productInfoDto = convertProductInfoDto(productInfo);
 
-    private static ProductInfoDto convertProductInfoDto(ProductInfo productInfo) {
-        return new ProductInfoDto(
-                productInfo.getProductId(),
-                productInfo.getName(),
-                productInfo.getDescription(),
-                productInfo.getPrice(),
-                productInfo.getQuantity(),
-                productInfo.getActive(),
-                productInfo.getAverageRating(),
-                productInfo.getReviewsCount(),
-                productInfo.getBrandName(),
-                productInfo.getSellerName()
-
-        );
+        return new FavoriteItemDto(favoriteItemEntityId, productInfoDto);
     }
 }

src/main/java/com/zufar/icedlatte/favorite/converter/ListOfFavoriteProductsDtoConverter.java

@@ -4,11 +4,7 @@
 import com.zufar.icedlatte.favorite.dto.FavoriteListDto;
 import com.zufar.icedlatte.openapi.dto.ListOfFavoriteProductsDto;
 import com.zufar.icedlatte.openapi.dto.ProductInfoDto;
-import org.mapstruct.InjectionStrategy;
-import org.mapstruct.Mapper;
-import org.mapstruct.Named;
-import org.mapstruct.ReportingPolicy;
-import org.mapstruct.MappingConstants;
+import org.mapstruct.*;
 
 import java.util.List;
 import java.util.Set;
@@ -17,13 +13,8 @@
         unmappedTargetPolicy = ReportingPolicy.IGNORE, injectionStrategy = InjectionStrategy.FIELD)
 public interface ListOfFavoriteProductsDtoConverter {
 
-    default ListOfFavoriteProductsDto toListProductDto(FavoriteListDto favoriteList) {
-        ListOfFavoriteProductsDto listOfFavoriteProductsDto = new ListOfFavoriteProductsDto();
-        for (FavoriteItemDto item : favoriteList.favoriteItems()) {
-            listOfFavoriteProductsDto.addProductsItem(item.productInfo());
-        }
-        return listOfFavoriteProductsDto;
-    }
+    @Mapping(target = "products", source = "favoriteItems", qualifiedByName = "toListProductInfoDto")
+    ListOfFavoriteProductsDto toListProductDto(FavoriteListDto favoriteList);
 
     @Named("toListProductInfoDto")
     default List<ProductInfoDto> toProductInfoDto(final Set<FavoriteItemDto> favoriteItems) {

src/main/java/com/zufar/icedlatte/review/converter/ProductReviewDtoConverter.java

@@ -5,41 +5,53 @@
 import com.zufar.icedlatte.openapi.dto.RatingMap;
 import com.zufar.icedlatte.review.dto.ProductRatingCount;
 import com.zufar.icedlatte.review.entity.ProductReview;
+import com.zufar.icedlatte.user.entity.UserEntity;
+import org.mapstruct.*;
 import org.springframework.data.domain.Page;
-import org.springframework.stereotype.Service;
 
 import java.util.List;
+import java.util.Optional;
 
-@Service
-public class ProductReviewDtoConverter {
+@Mapper(componentModel = MappingConstants.ComponentModel.SPRING,
+        uses = ProductReviewDtoConverter.class, unmappedTargetPolicy = ReportingPolicy.IGNORE, injectionStrategy = InjectionStrategy.FIELD)
+public interface ProductReviewDtoConverter {
 
-    public static final ProductReviewDto EMPTY_PRODUCT_REVIEW_RESPONSE =
-            new ProductReviewDto(null, null,null, null, null, null, null, null, null);
+    ProductReviewDto EMPTY_PRODUCT_REVIEW_RESPONSE =
+            new ProductReviewDto(null, null, null, null, null, null, null, null, null);
 
-    public ProductReviewDto toProductReviewDto(ProductReview productReview) {
-        return new ProductReviewDto(
-                productReview.getId(),
-                productReview.getProductId(),
-                productReview.getProductRating(),
-                productReview.getText(),
-                productReview.getCreatedAt(),
-                productReview.getUser().getFirstName(),
-                productReview.getUser().getLastName(),
-                productReview.getLikesCount(),
-                productReview.getDislikesCount());
+    @Mapping(target = "productReviewId", source = "id")
+    @Mapping(target = "productId", source = "productId")
+    @Mapping(target = "productRating", source = "productRating")
+    @Mapping(target = "text", source = "text")
+    @Mapping(target = "createdAt", source = "createdAt")
+    @Mapping(target = "userName", source = "user", qualifiedByName = "toUserName")
+    @Mapping(target = "userLastname", source = "user", qualifiedByName = "toUserLastName")
+    @Mapping(target = "likesCount", source = "likesCount")
+    @Mapping(target = "dislikesCount", source = "dislikesCount")
+    ProductReviewDto toProductReviewDto(ProductReview productReview);
+
+    @Mapping(target = "page", expression = "java(page.getTotalPages())")
+    @Mapping(target = "size", expression = "java(page.getSize())")
+    @Mapping(target = "totalElements", expression = "java(page.getTotalElements())")
+    @Mapping(target = "totalPages", expression = "java(page.getTotalPages())")
+    @Mapping(target = "reviewsWithRatings", expression = "java(page.getContent())")
+    ProductReviewsAndRatingsWithPagination toProductReviewsAndRatingsWithPagination(final Page<ProductReviewDto> page);
+
+    @Named("toUserName")
+    default String convertToUserName(UserEntity user) {
+        Optional<UserEntity> userOptional = Optional.of(user);
+        Optional<String> firstNameOptional = userOptional.map(UserEntity::getFirstName);
+        return firstNameOptional.orElse(null);
     }
 
-    public ProductReviewsAndRatingsWithPagination toProductReviewsAndRatingsWithPagination(final Page<ProductReviewDto> page) {
-        var result = new ProductReviewsAndRatingsWithPagination();
-        result.setPage(page.getTotalPages());
-        result.setSize(page.getSize());
-        result.setTotalElements(page.getTotalElements());
-        result.setTotalPages(page.getTotalPages());
-        result.setReviewsWithRatings(page.getContent());
-        return result;
+    @Named("toUserLastName")
+    default String convertToUserLastName(UserEntity user) {
+        Optional<UserEntity> userOptional = Optional.of(user);
+        Optional<String> lastNameOptional = userOptional.map(UserEntity::getLastName);
+        return lastNameOptional.orElse(null);
     }
 
-    public RatingMap convertToProductRatingMap(List<ProductRatingCount> productRatingCountPairs) {
+    default RatingMap convertToProductRatingMap(List<ProductRatingCount> productRatingCountPairs) {
         var productRatingMap = new RatingMap(0, 0, 0, 0, 0);
 
         for (ProductRatingCount productRatingCount : productRatingCountPairs) {

src/test/java/com/zufar/icedlatte/favorite/converter/FavoriteItemDtoConverterTest.java

@@ -0,0 +1,39 @@
+package com.zufar.icedlatte.favorite.converter;
+
+import com.zufar.icedlatte.favorite.dto.FavoriteItemDto;
+import com.zufar.icedlatte.favorite.entity.FavoriteItemEntity;
+import com.zufar.icedlatte.product.converter.ProductInfoDtoConverter;
+import com.zufar.icedlatte.product.entity.ProductInfo;
+import org.junit.jupiter.api.BeforeEach;
+import org.mapstruct.factory.Mappers;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+
+import java.util.UUID;
+
+public class FavoriteItemDtoConverterTest {
+
+    private FavoriteItemDtoConverter converter;
+    private ProductInfoDtoConverter productInfoDtoConverter;
+
+    @BeforeEach
+    void setup() {
+        converter = Mappers.getMapper(FavoriteItemDtoConverter.class);
+        productInfoDtoConverter = Mappers.getMapper(ProductInfoDtoConverter.class);
+    }
+
+    @Test
+    @DisplayName("Convert FavoriteItemEntity to FavoriteItemDto")
+    void toDtoTest() {
+
+        ProductInfo productInfo = new ProductInfo();
+        productInfo.setProductId(UUID.randomUUID());
+
+        FavoriteItemEntity expectedFavoriteItem = new FavoriteItemEntity();
+        expectedFavoriteItem.setProductInfo(productInfo);
+
+        FavoriteItemDto actualFavoriteItemDto = converter.toDto(productInfoDtoConverter, expectedFavoriteItem);
+        // FIXME: different types of sets
+        //assertThat(actualFavoriteItemDto.productInfo()).isEqualTo(expectedFavoriteItem.getProductInfo());
+    }
+}

src/test/java/com/zufar/icedlatte/favorite/converter/FavoriteListDtoConverterTest.java

@@ -0,0 +1,79 @@
+package com.zufar.icedlatte.favorite.converter;
+
+import com.zufar.icedlatte.favorite.dto.FavoriteListDto;
+import com.zufar.icedlatte.favorite.entity.FavoriteItemEntity;
+import com.zufar.icedlatte.favorite.entity.FavoriteListEntity;
+import com.zufar.icedlatte.openapi.dto.ProductInfoDto;
+import com.zufar.icedlatte.product.entity.ProductInfo;
+import com.zufar.icedlatte.user.stub.UserDtoTestStub;
+import org.junit.jupiter.api.BeforeEach;
+import org.mapstruct.factory.Mappers;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+
+import java.math.BigDecimal;
+import java.time.OffsetDateTime;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class FavoriteListDtoConverterTest {
+
+    private FavoriteListDtoConverter converter;
+
+    @BeforeEach
+    void setup() {
+        converter = Mappers.getMapper(FavoriteListDtoConverter.class);
+    }
+
+    @Test
+    @DisplayName("Convert FavoriteListEntity to FavoriteListDto")
+    void convertListEntityToDto() {
+
+        ProductInfo productInfo = new ProductInfo();
+        productInfo.setProductId(UUID.randomUUID());
+
+        FavoriteItemEntity favoriteItem = new FavoriteItemEntity();
+        favoriteItem.setProductInfo(productInfo);
+
+        FavoriteListEntity expectedFavoriteListEntity = FavoriteListEntity.builder()
+                .id(UUID.randomUUID())
+                .user(UserDtoTestStub.createUserEntity())
+                .favoriteItems(Set.of(favoriteItem))
+                .updatedAt(OffsetDateTime.now())
+                .build();
+
+        FavoriteListDto actualFavoriteListDto = converter.toDto(expectedFavoriteListEntity);
+
+        assertThat(actualFavoriteListDto.id()).isEqualTo(expectedFavoriteListEntity.getId());
+        assertThat(actualFavoriteListDto.updatedAt()).isEqualTo(expectedFavoriteListEntity.getUpdatedAt());
+        assertThat(actualFavoriteListDto.userId()).isEqualTo(Optional.of(expectedFavoriteListEntity.getUser()).get().getId());
+        // fIXME: how to test favoriteItems?
+//        assertThat(actualFavoriteListDto.favoriteItems()).isEqualTo(expectedFavoriteListEntity.getFavoriteItems());
+
+    }
+
+    @Test
+    @DisplayName("Convert ProductInfo to ProductInfoDto")
+    void convertToProductInfoDto() {
+
+        ProductInfo expectedProductInfo = new ProductInfo(UUID.randomUUID(), "Coffee", "Coffee description",
+                new BigDecimal(100), 1, true,  new BigDecimal(100), 1, "Jacobs", "Seller");
+
+        ProductInfoDto actualProductInfoDto = converter.convertProductInfoDto(expectedProductInfo);
+
+        assertThat(actualProductInfoDto.getId()).isEqualTo(expectedProductInfo.getProductId());
+        assertThat(actualProductInfoDto.getName()).isEqualTo(expectedProductInfo.getName());
+        assertThat(actualProductInfoDto.getDescription()).isEqualTo(expectedProductInfo.getDescription());
+        assertThat(actualProductInfoDto.getPrice()).isEqualTo(expectedProductInfo.getPrice());
+        assertThat(actualProductInfoDto.getQuantity()).isEqualTo(expectedProductInfo.getQuantity());
+        assertThat(actualProductInfoDto.getActive()).isEqualTo(expectedProductInfo.getActive());
+        assertThat(actualProductInfoDto.getAverageRating()).isEqualTo(expectedProductInfo.getAverageRating());
+        assertThat(actualProductInfoDto.getReviewsCount()).isEqualTo(expectedProductInfo.getReviewsCount());
+        assertThat(actualProductInfoDto.getBrandName()).isEqualTo(expectedProductInfo.getBrandName());
+        assertThat(actualProductInfoDto.getSellerName()).isEqualTo(expectedProductInfo.getSellerName());
+    }
+
+}

src/test/java/com/zufar/icedlatte/favorite/converter/ListOfFavoriteProductsDtoConverterTest.java

@@ -0,0 +1,48 @@
+package com.zufar.icedlatte.favorite.converter;
+
+import com.zufar.icedlatte.favorite.dto.FavoriteItemDto;
+import com.zufar.icedlatte.favorite.dto.FavoriteListDto;
+import com.zufar.icedlatte.openapi.dto.ListOfFavoriteProductsDto;
+import com.zufar.icedlatte.openapi.dto.ProductInfoDto;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+import org.mapstruct.factory.Mappers;
+
+import java.time.OffsetDateTime;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ListOfFavoriteProductsDtoConverterTest {
+
+    private ListOfFavoriteProductsDtoConverter converter;
+
+    @BeforeEach
+    void setup() {
+        converter = Mappers.getMapper(ListOfFavoriteProductsDtoConverter.class);
+    }
+
+    @Test
+    @DisplayName("Convert FavoriteListDto to ListOfFavoriteProductsDto")
+    void toListProductDto() {
+
+        ProductInfoDto productInfoDto = new ProductInfoDto();
+        productInfoDto.setId(UUID.randomUUID());
+
+        FavoriteItemDto favoriteItemDto = new FavoriteItemDto(
+                UUID.randomUUID(),
+                productInfoDto);
+
+        FavoriteListDto expectedFavoriteListDto = new FavoriteListDto(
+                UUID.randomUUID(),
+                UUID.randomUUID(),
+                Set.of(favoriteItemDto),
+                OffsetDateTime.now());
+
+        ListOfFavoriteProductsDto actualListOfFavoriteProductsDto = converter.toListProductDto(expectedFavoriteListDto);
+
+        assertThat(actualListOfFavoriteProductsDto.getProducts()).isEqualTo(converter.toProductInfoDto(expectedFavoriteListDto.favoriteItems()));
+    }
+}

src/test/java/com/zufar/icedlatte/review/api/ProductAverageRatingProviderTest.java

@@ -52,7 +52,7 @@ void getRatingAndReviewStatsSuccessful() {
         var reviewsCount = 0;
 
         var expectedRatingMap = new RatingMap(1, 0, 0, 0, 0);
-        var expectedStats = new ProductReviewRatingStats(randomID, "0.0", reviewsCount, expectedRatingMap);
+        var expectedStats = new ProductReviewRatingStats(randomID, "0,0", reviewsCount, expectedRatingMap);
         when(reviewRepository.getRatingsMapByProductId(randomID)).thenReturn(listOfMappings);
         when(reviewRepository.getAvgRatingByProductId(randomID)).thenReturn(0.0);
         when(reviewRepository.getReviewCountProductById(randomID)).thenReturn(reviewsCount);