end lab 2

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "java.dependency.packagePresentation": "hierarchical"
+}

src/main/java/com/example/demo/DemoApplication.java

@@ -1,7 +1,7 @@
 package com.example.demo;
 
+import java.util.Arrays;
 import java.util.Date;
-import java.util.List;
 import java.util.Objects;
 
 import org.slf4j.Logger;
@@ -10,6 +10,7 @@ import org.springframework.boot.CommandLineRunner;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
+import com.example.demo.orders.api.OrderProductDto;
 import com.example.demo.orders.model.OrdersEntity;
 import com.example.demo.orders.service.OrdersService;
 import com.example.demo.products.model.ProductsEntity;
@@ -43,7 +44,7 @@ public class DemoApplication implements CommandLineRunner {
 
 	@Override
 	public void run(String... args) throws Exception {
-		if (args.length > 0 && Objects.equals("--populate", args[0])) {
+		//if (args.length > 0 && Objects.equals("--populate", args[0])) {
 
 			log.info("Создание пользователей");
 			final var user1 = userService.create(new UsersEntity("Anton", "1234"));
@@ -59,13 +60,13 @@ public class DemoApplication implements CommandLineRunner {
 			final var product3 = productsService.create(new ProductsEntity(type2, "Компьютер 3", 150000.00));
 
 			log.info("Создание заказов");
+			
+			ordersService.create(user1.getId(), new OrdersEntity( new Date()), Arrays.asList(
+				new OrderProductDto(product1.getId(), 3),
+				new OrderProductDto(product2.getId(), 1),
+				new OrderProductDto(product3.getId(), 1)
+			));
 
-			final var orders = List.of(
-					new OrdersEntity(product1, 3, new Date()),
-					new OrdersEntity(product2, 2, new Date()),
-					new OrdersEntity(product3, 1, new Date()),
-					new OrdersEntity(product1, 4, new Date()));
-			orders.forEach(order -> ordersService.create(user1.getId(), order));
-		}
+		//}
 	}
 }

src/main/java/com/example/demo/orderproducts/model/OrderProductsEntity.java

@@ -0,0 +1,83 @@
+package com.example.demo.orderproducts.model;
+
+
+import java.util.Objects;
+
+import com.example.demo.core.model.BaseEntity;
+import com.example.demo.orders.model.OrdersEntity;
+import com.example.demo.products.model.ProductsEntity;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "orders_products")
+public class OrderProductsEntity extends BaseEntity {
+
+
+    @ManyToOne
+    @JoinColumn(name = "order_id")
+    private OrdersEntity order;
+
+    @ManyToOne
+    @JoinColumn(name = "product_id")
+    private ProductsEntity product;
+
+    @Column(nullable = false)
+    private Integer count;
+
+
+    public OrderProductsEntity() {
+    }
+
+    public OrderProductsEntity(OrdersEntity order, ProductsEntity product, Integer count) {
+        this.order = order;
+        this.product = product;
+        this.count = count;
+    }
+
+
+    public OrdersEntity getOrder() {
+        return order;
+    }
+
+    public void setOrder(OrdersEntity order) {
+        this.order = order;
+        if (!order.getOrderProducts().contains(this)) {
+            order.getOrderProducts().add(this);
+        }
+    }
+
+    public ProductsEntity getProduct() {
+        return product;
+    }
+
+     public Integer getCount() {
+        return count;
+    }
+
+    public void setCount(Integer count) {
+        this.count = count;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, order.getId(), product.getId(), count);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null || getClass() != obj.getClass())
+            return false;
+        OrderProductsEntity other = (OrderProductsEntity) obj;
+        return Objects.equals(id, other.id)
+                && Objects.equals(order.getId(), other.order.getId())
+                && Objects.equals(product.getId(), other.product.getId())
+                && count == other.count;
+    }
+}

src/main/java/com/example/demo/orderproducts/model/OrderProductsId.java

@@ -0,0 +1,52 @@
+package com.example.demo.orderproducts.model;
+
+import java.util.Objects;
+import java.util.Optional;
+
+
+public class OrderProductsId {
+    private Long orderId;
+    private Long productId;
+
+    public OrderProductsId() {
+    }
+
+    public OrderProductsId(Long orderId, Long productId) {
+        this.orderId = orderId;
+        this.productId = productId;
+    }
+
+    public Long getOrderId() {
+        return orderId;
+    }
+
+    public void setOrderId(Long orderId) {
+        this.orderId = orderId;
+    }
+
+    public Long getProductId() {
+        return productId;
+    }
+
+    public void setProductId(Long productId) {
+        this.productId = productId;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(
+                Optional.ofNullable(orderId).orElse(0L),
+                Optional.ofNullable(productId).orElse(0L));
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null || getClass() != obj.getClass())
+            return false;
+        OrderProductsId other = (OrderProductsId) obj;
+        return Objects.equals(orderId, other.orderId)
+                && Objects.equals(productId, other.productId);
+    }
+}

src/main/java/com/example/demo/orders/api/OrderProductDto.java

@@ -0,0 +1,32 @@
+package com.example.demo.orders.api;
+
+import jakarta.validation.constraints.NotNull;
+
+public class OrderProductDto {
+    private Long productId;
+    @NotNull
+    private Integer count;
+
+    public OrderProductDto(Long productId, Integer count) {
+        this.productId = productId;
+        this.count = count;
+    }
+    public OrderProductDto() {
+    }
+
+    public Long getProductId() {
+        return productId;
+    }
+
+    public void setProductId(Long id) {
+        this.productId = id;
+    }
+
+    public Integer getCount() {
+        return count;
+    }
+
+    public void setCount(Integer count) {
+        this.count = count;
+    }
+}

src/main/java/com/example/demo/orders/api/OrdersController.java

@@ -1,10 +1,8 @@
 package com.example.demo.orders.api;
 
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.Date;
 import java.util.List;
 
+import org.hibernate.Hibernate;
 import org.modelmapper.ModelMapper;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -19,8 +17,8 @@ import org.springframework.web.bind.annotation.RestController;
 import com.example.demo.core.configuration.Constants;
 import com.example.demo.orders.model.OrdersEntity;
 import com.example.demo.orders.service.OrdersService;
+import com.example.demo.products.api.ProductsDto;
 import com.example.demo.products.model.ProductsEntity;
-import com.example.demo.products.service.ProductsService;
 
 import jakarta.validation.Valid;
 
@@ -28,42 +26,30 @@ import jakarta.validation.Valid;
 @RequestMapping(Constants.API_URL + "/user/{user}/order")
 public class OrdersController {
     private final OrdersService ordersService;
-    private final ProductsService productsService;
     private final ModelMapper modelMapper;
-    private SimpleDateFormat formater = new SimpleDateFormat("dd.MM.yyyy");
 
-    public OrdersController(OrdersService ordersService, ProductsService productsService, ModelMapper modelMapper) {
+    public OrdersController(OrdersService ordersService, ModelMapper modelMapper) {
         this.ordersService = ordersService;
-        this.productsService = productsService;
         this.modelMapper = modelMapper;
     }
 
-    public Date StringConvertDate(String date) {
-
-        try {
-            return formater.parse(date);
-        } catch (ParseException e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-
-    public String DateConvertString(Date date) {
-        return formater.format(date);
-    }
-
     private OrdersDto toDto(OrdersEntity entity) {
-        // String dateEntity = DateConvertString(entity.getDate());
-        // entity.setDate(dateEntity);
-        return modelMapper.map(entity, OrdersDto.class);
+        Hibernate.initialize(entity.getOrderProducts());
+        final OrdersDto dto = modelMapper.map(entity, OrdersDto.class);
+        dto.setSum(ordersService.getSum(entity.getUser().getId(), entity.getId()));
+        dto.setCount(ordersService.getFullCount(entity.getUser().getId(), entity.getId()));
+        return dto;
     }
 
     private OrdersEntity toEntity(OrdersDto dto) {
         final OrdersEntity entity = modelMapper.map(dto, OrdersEntity.class);
-        entity.setProduct(productsService.get(dto.getProductId()));
         return entity;
     }
 
+    private ProductsDto toProductDto(ProductsEntity entity) {
+        return modelMapper.map(entity, ProductsDto.class);
+    }
+
     @GetMapping
     public List<OrdersDto> getAll(@PathVariable(name = "user") Long userId,
             @RequestParam(name = "productId", defaultValue = "0") ProductsEntity product) {
@@ -77,17 +63,24 @@ public class OrdersController {
 
     @PostMapping
     public OrdersDto create(@PathVariable(name = "user") Long userId, @RequestBody @Valid OrdersDto dto) {
-        return toDto(ordersService.create(userId, toEntity(dto)));
+        return toDto(ordersService.create(userId, toEntity(dto), dto.getOrderProducts()));
     }
 
     @PutMapping("/{id}")
     public OrdersDto update(@PathVariable(name = "user") Long userId, @PathVariable(name = "id") Long id,
             @RequestBody OrdersDto dto) {
-        return toDto(ordersService.update(userId, id, toEntity(dto)));
+        return toDto(ordersService.update(userId, id, toEntity(dto), dto.getOrderProducts()));
     }
 
     @DeleteMapping("/{id}")
     public OrdersDto delete(@PathVariable(name = "user") Long userId, @PathVariable(name = "id") Long id) {
         return toDto(ordersService.delete(userId, id));
     }
+
+    @GetMapping("/{id}/product")
+    public List<ProductsDto> getOrderProducts(
+            @PathVariable(name = "user") Long userId,
+            @PathVariable(name = "id") Long id) {
+        return ordersService.getOrderProducts(userId, id).stream().map(this::toProductDto).toList();
+    }
 }

src/main/java/com/example/demo/orders/api/OrdersDto.java

@@ -1,23 +1,30 @@
 package com.example.demo.orders.api;
 
+import java.util.List;
 import java.util.Date;
 
-import com.example.demo.products.model.ProductsEntity;
 import com.fasterxml.jackson.annotation.JsonProperty;
 
-import jakarta.validation.constraints.Min;
 import jakarta.validation.constraints.NotNull;
 
 public class OrdersDto {
     @JsonProperty(access = JsonProperty.Access.READ_ONLY)
     private Long id;
-    @NotNull
-    private ProductsEntity product;
-    @NotNull
-    @Min(1)
+    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
+    private Double sum;
+    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
     private Integer count;
     @NotNull
     private Date date;
+    private List<OrderProductDto> orderProducts;
+
+    public List<OrderProductDto> getOrderProducts() {
+        return orderProducts;
+    }
+
+    public void setOrderProducts(List<OrderProductDto> orderProducts) {
+        this.orderProducts = orderProducts;
+    }
 
     public Long getId() {
         return id;
@@ -27,22 +34,6 @@ public class OrdersDto {
         this.id = id;
     }
 
-    public ProductsEntity getProduct() {
-        return product;
-    }
-
-    public void setProduct(ProductsEntity product) {
-        this.product = product;
-    }
-
-    public Long getProductId() {
-        return product.getId();
-    }
-
-    public void setProductId(Long productId) {
-        productId = product.getId();
-    }
-
     public Integer getCount() {
         return count;
     }
@@ -59,9 +50,12 @@ public class OrdersDto {
         this.date = date;
     }
 
-    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
     public Double getSum() {
-        return count * product.getPrice();
+        return sum;
+    }
+
+    public void setSum(Double sum) {
+        this.sum = sum;
     }
 
 }

src/main/java/com/example/demo/orders/model/OrdersEntity.java

@@ -3,55 +3,45 @@ package com.example.demo.orders.model;
 import java.util.Date;
 import java.util.Objects;
 
+
+import java.util.Set;
+import java.util.HashSet;
 import com.example.demo.core.model.BaseEntity;
-import com.example.demo.products.model.ProductsEntity;
+import com.example.demo.orderproducts.model.OrderProductsEntity;
 import com.example.demo.users.model.UsersEntity;
 
 import jakarta.persistence.Temporal;
 import jakarta.persistence.TemporalType;
-import jakarta.persistence.Column;
+import jakarta.persistence.CascadeType;
 import jakarta.persistence.Entity;
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.OrderBy;
 import jakarta.persistence.Table;
 
 @Entity
 @Table(name = "orders")
 public class OrdersEntity extends BaseEntity {
-    @ManyToOne
-    @JoinColumn(name = "productId", nullable = false)
-    private ProductsEntity product;
+
+    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
+    @OrderBy("id ASC")
+    private Set<OrderProductsEntity> orderProducts = new HashSet<>();
 
     @ManyToOne
     @JoinColumn(name = "userId", nullable = false)
     private UsersEntity user;
 
-    @Column(nullable = false)
-    private Integer count;
-
-    private Double sum;
-
     @Temporal(TemporalType.DATE)
     private Date date;
 
     public OrdersEntity() {
     }
 
-    public OrdersEntity(ProductsEntity product, Integer count, Date date) {
-        this.product = product;
-        this.count = count;
-        this.sum = getSum();
+    public OrdersEntity(Date date) {
         this.date = date;
     }
 
-    public ProductsEntity getProduct() {
-        return product;
-    }
-
-    public void setProduct(ProductsEntity product) {
-        this.product = product;
-    }
-
     public UsersEntity getUser() {
         return user;
     }
@@ -63,17 +53,27 @@ public class OrdersEntity extends BaseEntity {
         }
     }
 
-    public Double getSum() {
-        sum = count * product.getPrice();
-        return sum;
+
+    public Set<OrderProductsEntity> getOrderProducts() {
+        return orderProducts;
     }
 
-    public Integer getCount() {
-        return count;
+    public void setOrdersProducts(Set<OrderProductsEntity> set) {
+        this.orderProducts = set;
     }
 
-    public void setCount(Integer count) {
-        this.count = count;
+    public void addProduct(OrderProductsEntity orderProduct) {
+        if (orderProduct.getOrder() != this) {
+            orderProduct.setOrder(this);
+        }
+        orderProducts.add(orderProduct);
+    }
+
+    public void deleteProduct(OrderProductsEntity orderProduct) {
+        if (orderProduct.getOrder() != this) {
+            return;
+        }
+        orderProducts.remove(orderProduct);
     }
 
     public Date getDate() {
@@ -84,9 +84,10 @@ public class OrdersEntity extends BaseEntity {
         this.date = date;
     }
 
+    
     @Override
     public int hashCode() {
-        return Objects.hash(id, product, count);
+        return Objects.hash(id, date);
     }
 
     @Override
@@ -97,9 +98,8 @@ public class OrdersEntity extends BaseEntity {
             return false;
         final OrdersEntity other = (OrdersEntity) obj;
         return Objects.equals(other.getId(), id)
-                && Objects.equals(other.getProduct(), product)
                 && Objects.equals(other.getUser().getId(), user.getId())
-                && Objects.equals(other.getCount(), count)
+                && Objects.equals(other.getOrderProducts(), orderProducts)
                 && Objects.equals(other.getDate(), date);
     }
 }

src/main/java/com/example/demo/orders/service/OrdersService.java

@@ -1,13 +1,18 @@
 package com.example.demo.orders.service;
 
 import java.util.List;
+import java.util.ArrayList;
 
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import com.example.demo.core.error.NotFoundException;
+import com.example.demo.orderproducts.model.OrderProductsEntity;
+import com.example.demo.orders.api.OrderProductDto;
 import com.example.demo.orders.model.OrdersEntity;
 import com.example.demo.orders.repository.OrdersRepository;
+import com.example.demo.products.model.ProductsEntity;
+import com.example.demo.products.service.ProductsService;
 import com.example.demo.users.model.UsersEntity;
 import com.example.demo.users.service.UsersService;
 
@@ -15,10 +20,12 @@ import com.example.demo.users.service.UsersService;
 public class OrdersService {
     private final OrdersRepository repository;
     private final UsersService userService;
+    private final ProductsService productService;
 
-    public OrdersService(OrdersRepository repository, UsersService userService) {
+    public OrdersService(OrdersRepository repository, UsersService userService, ProductsService productService) {
         this.repository = repository;
         this.userService = userService;
+        this.productService = productService;
     }
 
     @Transactional(readOnly = true)
@@ -35,22 +42,37 @@ public class OrdersService {
     }
 
     @Transactional
-    public OrdersEntity create(long userId, OrdersEntity entity) {
+    public OrdersEntity create(long userId, OrdersEntity entity,List<OrderProductDto> orderProductList) {
         if (entity == null) {
             throw new IllegalArgumentException("Entity is null");
         }
         final UsersEntity existsUser = userService.get(userId);
         entity.setUser(existsUser);
+        entity = repository.save(entity);
+
+        List<OrderProductsEntity> orderProductListEntities = new ArrayList<OrderProductsEntity>();
+        for (OrderProductDto element : orderProductList) {
+            OrderProductsEntity orderProductEntity = new OrderProductsEntity(entity, productService.get(element.getProductId()), element.getCount());
+            
+            orderProductEntity.setOrder(entity);
+            orderProductListEntities.add(orderProductEntity);
+            entity.addProduct(orderProductEntity);
+        }
         return repository.save(entity);
     }
 
+    
+
     @Transactional
-    public OrdersEntity update(long userId, Long id, OrdersEntity entity) {
+    public OrdersEntity update(long userId, Long id, OrdersEntity entity, List<OrderProductDto> orderProductList) {
         userService.get(userId);
         final OrdersEntity existsEntity = get(userId, id);
-        existsEntity.setProduct(entity.getProduct());
-        existsEntity.setCount(entity.getCount());
         existsEntity.setDate(entity.getDate());
+        existsEntity.getOrderProducts().clear();
+        for (OrderProductDto dto : orderProductList) {
+            OrderProductsEntity orderProductEntity = new OrderProductsEntity(existsEntity, productService.get(dto.getProductId()), dto.getCount());
+            existsEntity.addProduct(orderProductEntity);
+        }
         return repository.save(existsEntity);
     }
 
@@ -62,10 +84,22 @@ public class OrdersService {
         return existsEntity;
     }
 
-    // @Transactional(readOnly = true)
-    // public List<OrdersGrouped> getTotal(long userId) {
-    // //userService.get(userId);
-    // return repository.getOrdersTotalByUser(userId);
-    // }
+    @Transactional(readOnly = true)
+    public List<ProductsEntity> getOrderProducts(long userId, long id) {
+        userService.get(userId);
+        return get(userId, id).getOrderProducts().stream().map(orderProduct -> orderProduct.getProduct()).toList();
+    }
+
+    @Transactional(readOnly = true)
+    public Double getSum(long userId, long id) {
+        userService.get(userId);
+        return get(userId, id).getOrderProducts().stream().mapToDouble(orderProduct -> orderProduct.getCount() * orderProduct.getProduct().getPrice()).sum();
+    }
+
+    @Transactional(readOnly = true)
+    public Integer getFullCount(long userId, long id) {
+        userService.get(userId);
+        return get(userId, id).getOrderProducts().stream().mapToInt(OrderProductsEntity::getCount).sum();
+    }
 
 }

src/test/java/com/example/demo/OrdersServiceTests.java

@@ -0,0 +1,114 @@
+package com.example.demo;
+
+import java.util.Date;
+import java.util.Arrays;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import com.example.demo.orders.api.OrderProductDto;
+import com.example.demo.orders.model.OrdersEntity;
+import com.example.demo.orders.service.OrdersService;
+import com.example.demo.products.model.ProductsEntity;
+import com.example.demo.products.service.ProductsService;
+import com.example.demo.types.model.TypesEntity;
+import com.example.demo.types.service.TypesService;
+import com.example.demo.users.model.UsersEntity;
+import com.example.demo.users.service.UsersService;
+
+import jakarta.transaction.Transactional;
+
+@SpringBootTest
+class OrdersServiceTests {
+
+	@Autowired
+    private TypesService typeService;
+
+    @Autowired
+    private ProductsService productService;
+
+    @Autowired
+    private UsersService userService;
+
+    @Autowired
+    private OrdersService orderService;
+
+    private OrdersEntity order;
+
+    private UsersEntity user;
+
+    private ProductsEntity product1;
+    private ProductsEntity product2;
+    private ProductsEntity product3;
+
+    @BeforeEach
+    void createData() {
+        removeData();
+
+        final var type = typeService.create(new TypesEntity("Телефон"));
+        product1 = productService.create(new ProductsEntity(type,"Nokia 2000", 399.00));
+		product2 = productService.create(new ProductsEntity(type,"Nokia 2002", 499.00));
+		product3 = productService.create(new ProductsEntity(type,"Nokia 2007", 450.50));
+        user = userService.create(new UsersEntity("Antosha","qwerty123"));
+        order = orderService.create(user.getId(), new OrdersEntity(new Date()), Arrays.asList(
+				new OrderProductDto(product1.getId(), 3),
+				new OrderProductDto(product2.getId(), 1),
+				new OrderProductDto(product3.getId(), 2)));
+        orderService.create(user.getId(), new OrdersEntity(new Date()), Arrays.asList(
+            new OrderProductDto(product1.getId(), 5)));
+        orderService.create(user.getId(), new OrdersEntity(new Date()), Arrays.asList(
+            new OrderProductDto(product2.getId(), 1),
+            new OrderProductDto(product3.getId(), 1)));
+    }
+
+    @AfterEach
+    void removeData() {
+        userService.getAll().forEach(item -> userService.delete(item.getId()));
+        productService.getAll().forEach(item -> productService.delete(item.getId()));
+        typeService.getAll().forEach(item -> typeService.delete(item.getId()));
+    }
+
+    @Transactional
+    @Test
+    void createTest() {
+        Assertions.assertEquals(3, orderService.getAll(user.getId()).size());
+        Assertions.assertEquals(order, orderService.get(user.getId(), order.getId()));
+    }
+
+    @Transactional
+    @Test
+    void updateTest() {
+        final OrdersEntity newEntity = orderService.update(user.getId(), order.getId(), new OrdersEntity(new Date()), Arrays.asList(
+            new OrderProductDto(product1.getId(), 5)));
+        Assertions.assertEquals(3, orderService.getAll(user.getId()).size());
+        Assertions.assertEquals(newEntity, orderService.get(user.getId(), order.getId()));
+    }
+
+    @Test
+    void deleteTest() {
+        orderService.delete(user.getId(), order.getId());
+        Assertions.assertEquals(2, orderService.getAll(user.getId()).size());
+
+        final OrdersEntity newEntity = orderService.create(user.getId(), new OrdersEntity(new Date()), Arrays.asList(
+            new OrderProductDto(product1.getId(), 5)));
+        Assertions.assertEquals(3, orderService.getAll(user.getId()).size());
+        Assertions.assertNotEquals(order.getId(), newEntity.getId());
+    }
+
+    @Test
+    void getSumTest() {
+        Double sum = orderService.getSum(user.getId(), order.getId());
+        Assertions.assertEquals(product1.getPrice() * 3 + product2.getPrice() + product3.getPrice() * 2, sum);
+    }
+
+    @Test
+    void getFullCountTest() {
+        Integer count = orderService.getFullCount(user.getId(), order.getId());
+        Assertions.assertEquals(6, count);
+    }
+	
+}

src/test/java/com/example/demo/UserServiceTests.java

@@ -0,0 +1,61 @@
+package com.example.demo;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import com.example.demo.users.model.UsersEntity;
+import com.example.demo.users.service.UsersService;
+
+@SpringBootTest
+public class UserServiceTests {
+
+    @Autowired
+    private UsersService userService;
+
+    private UsersEntity user;
+
+    @BeforeEach
+    void createData() {
+        removeData();
+
+        user = userService.create(new UsersEntity("Anton", "1234"));
+		userService.create(new UsersEntity("Daria", "4567"));
+    }
+
+    @AfterEach
+    void removeData() {
+        userService.getAll().forEach(item -> userService.delete(item.getId()));
+    }
+    
+    @Test
+    void createTest() {
+        Assertions.assertEquals(2, userService.getAll().size());
+        Assertions.assertEquals(user, userService.get(user.getId()));
+    }
+
+    @Test
+    void updateTest() {
+        final String test = "TEST";
+        final String oldLogin = user.getLogin();
+        final UsersEntity newEntity = userService.update(user.getId(), new UsersEntity("Anton123", "1234"));
+        Assertions.assertEquals(2, userService.getAll().size());
+        Assertions.assertEquals(newEntity, userService.get(user.getId()));
+        Assertions.assertNotEquals(test, newEntity.getLogin());
+        Assertions.assertNotEquals(oldLogin, newEntity.getLogin());
+    }
+
+    @Test
+    void deleteTest() {
+        userService.delete(user.getId());
+        Assertions.assertEquals(1, userService.getAll().size());
+
+        final UsersEntity newEntity = userService.create(new UsersEntity("Anton123", "1234"));
+        Assertions.assertEquals(2, userService.getAll().size());
+        Assertions.assertNotEquals(user.getId(), newEntity.getId());
+    }
+
+}

src/test/java/com/example/demo/UsersOrdersServiceTests.java

@@ -1,141 +0,0 @@
-package com.example.demo;
-
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.List;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestMethodOrder;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.context.SpringBootTest;
-
-import com.example.demo.orders.model.OrdersEntity;
-import com.example.demo.orders.service.OrdersService;
-import com.example.demo.products.model.ProductsEntity;
-import com.example.demo.products.service.ProductsService;
-import com.example.demo.types.model.TypesEntity;
-import com.example.demo.types.service.TypesService;
-import com.example.demo.users.model.UsersEntity;
-import com.example.demo.users.service.UsersService;
-
-@SpringBootTest
-@TestMethodOrder(OrderAnnotation.class)
-class UsersOrdersServiceTests {
-	@Autowired
-	private UsersService usersService;
-	@Autowired
-	private OrdersService ordersService;
-	@Autowired
-	private ProductsService productsService;
-	@Autowired
-	private TypesService typesService;
-
-	private UsersEntity user1;
-	private UsersEntity user2;
-
-	private ProductsEntity product;
-	private TypesEntity type;
-	private OrdersEntity order;
-	private SimpleDateFormat formater = new SimpleDateFormat("dd.MM.yyyy");
-
-	public String DateConvertString(Date date) {
-		return formater.format(date);
-	}
-
-	@BeforeEach
-	void createData() {
-		removeData();
-
-		type = typesService.create(new TypesEntity("Телефон"));
-
-		product = productsService.create(new ProductsEntity(type, "Nokia 2000", 1000.00));
-
-		user1 = usersService.create(new UsersEntity("Anton", "1234"));
-		user2 = usersService.create(new UsersEntity("Daria", "4567"));
-
-		final var orders = List.of(
-				new OrdersEntity(product, 3, new Date()),
-				new OrdersEntity(product, 2, new Date()),
-				new OrdersEntity(product, 1, new Date()),
-				new OrdersEntity(product, 4, new Date()));
-		orders.forEach(order -> ordersService.create(user1.getId(), order));
-		final var orders2 = List.of(
-				new OrdersEntity(product, 1, new Date()),
-				new OrdersEntity(product, 1, new Date()),
-				new OrdersEntity(product, 1, new Date()),
-				new OrdersEntity(product, 1, new Date()),
-				new OrdersEntity(product, 1, new Date()));
-		orders2.forEach(order -> ordersService.create(user2.getId(), order));
-		// order = ordersService.get(user1.getId(), 1);
-		order = orders.get(0);
-	}
-
-	@AfterEach
-	void removeData() {
-		usersService.getAll().forEach(item -> usersService.delete(item.getId()));
-		productsService.getAll().forEach(item -> productsService.delete(item.getId()));
-		typesService.getAll().forEach(item -> typesService.delete(item.getId()));
-	}
-
-	@Test
-	void getOrderTest() {
-		Assertions.assertEquals(4, ordersService.getAll(user1.getId()).size());
-		Assertions.assertEquals(5, ordersService.getAll(user2.getId()).size());
-	}
-
-	@Test
-	void getUserTest() {
-		Assertions.assertEquals(2, usersService.getAll().size());
-	}
-
-	@Test
-	void updateOrderTest() {
-		final Integer newCount = 5;
-		final OrdersEntity entity = ordersService.get(user1.getId(), order.getId());
-		final Integer oldCount = entity.getCount();
-		final OrdersEntity newEntity = ordersService.update(user1.getId(), order.getId(),
-				new OrdersEntity(product, newCount, new Date()));
-		Assertions.assertEquals(4, ordersService.getAll(user1.getId()).size());
-		Assertions.assertEquals(newCount, newEntity.getCount());
-		Assertions.assertNotEquals(oldCount, newEntity.getCount());
-	}
-
-	@Test
-	void updateUserTest() {
-		final String newPassword = "0000";
-		final UsersEntity entity = usersService.get(user1.getId());
-		final String login = entity.getLogin();
-		final String oldPassword = entity.getPassword();
-		final UsersEntity newEntity = usersService.update(user1.getId(), new UsersEntity(login, newPassword));
-		Assertions.assertEquals(2, usersService.getAll().size());
-		Assertions.assertEquals(newEntity, usersService.get(newEntity.getId()));
-		Assertions.assertEquals(newPassword, newEntity.getPassword());
-		Assertions.assertNotEquals(oldPassword, newEntity.getPassword());
-	}
-
-	@Test
-	void deleteOrderTest() {
-		ordersService.delete(user1.getId(), order.getId());
-		Assertions.assertEquals(3, ordersService.getAll(user1.getId()).size());
-
-		final OrdersEntity newEntity = ordersService.create(user1.getId(), new OrdersEntity(product, 3, new Date()));
-		Assertions.assertEquals(4, ordersService.getAll(user1.getId()).size());
-		Assertions.assertNotEquals(order.getId(), newEntity.getId());
-	}
-
-	@Test
-	void deleteUserTest() {
-		usersService.delete(user1.getId());
-		Assertions.assertEquals(1, usersService.getAll().size());
-
-		final UsersEntity newEntity = usersService.create(new UsersEntity("Anton",
-				"1234"));
-		Assertions.assertEquals(2, usersService.getAll().size());
-		Assertions.assertNotEquals(user1.getId(), newEntity.getId());
-	}
-
-}