deps: Refactor dependencies (#3224)

* remove spring dep
move junit, logging, mockito under dep mgmt

* upgrade anti-corruption-layer deps

* async method invocation

* balking, bloc

* bridge to bytecode

* caching

* callback - cqrs

* component - health check

* hexagonal - metadata mapping

* rest of the patterns

* remove checkstyle, take spotless into use

session-facade/src/main/java/com/iluwatar/sessionfacade/App.java

@@ -26,23 +26,19 @@
 package com.iluwatar.sessionfacade;
 
 /**
- * The main entry point of the application that demonstrates the usage
- * of the ShoppingFacade to manage the shopping process using the Session Facade pattern.
- * This class serves as a client that interacts with the simplified
- * interface provided by the ShoppingFacade, which encapsulates
- * complex interactions with the underlying business services.
- * The ShoppingFacade acts as a session bean that coordinates the communication
- * between multiple services, hiding their complexity and providing a single, unified API.
+ * The main entry point of the application that demonstrates the usage of the ShoppingFacade to
+ * manage the shopping process using the Session Facade pattern. This class serves as a client that
+ * interacts with the simplified interface provided by the ShoppingFacade, which encapsulates
+ * complex interactions with the underlying business services. The ShoppingFacade acts as a session
+ * bean that coordinates the communication between multiple services, hiding their complexity and
+ * providing a single, unified API.
  */
 public class App {
   /**
-   * The entry point of the application.
-   * This method demonstrates how the ShoppingFacade, acting as a Session Facade, is used to:
-   * - Add items to the shopping cart
-   * - Process a payment
-   * - Place the order
-   * The session facade manages the communication between the individual services
-   * and simplifies the interactions for the client.
+   * The entry point of the application. This method demonstrates how the ShoppingFacade, acting as
+   * a Session Facade, is used to: - Add items to the shopping cart - Process a payment - Place the
+   * order The session facade manages the communication between the individual services and
+   * simplifies the interactions for the client.
    *
    * @param args the input arguments
    */

session-facade/src/main/java/com/iluwatar/sessionfacade/CartService.java

@@ -25,29 +25,24 @@
 
 package com.iluwatar.sessionfacade;
 
-
 import java.util.Map;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 
 /**
- * The type Cart service.
- * Represents the cart entity, has add to cart and remove from cart methods
+ * The type Cart service. Represents the cart entity, has add to cart and remove from cart methods
  */
 @Slf4j
 public class CartService {
-  /**
-   * -- GETTER --
-   *  Gets cart.
-   */
-  @Getter
-  private final Map<Integer, Product> cart;
+  /** -- GETTER -- Gets cart. */
+  @Getter private final Map<Integer, Product> cart;
+
   private final Map<Integer, Product> productCatalog;
 
   /**
    * Instantiates a new Cart service.
    *
-   * @param cart           the cart
+   * @param cart the cart
    * @param productCatalog the product catalog
    */
   public CartService(Map<Integer, Product> cart, Map<Integer, Product> productCatalog) {
@@ -83,5 +78,4 @@ public class CartService {
       LOGGER.info("No product is found in cart with id {}", productId);
     }
   }
-
 }

session-facade/src/main/java/com/iluwatar/sessionfacade/OrderService.java

@@ -29,12 +29,11 @@ import java.util.Map;
 import lombok.extern.slf4j.Slf4j;
 
 /**
- * The OrderService class is responsible for finalizing a customer's order.
- * It includes a method to calculate the total cost of the order, which follows
- * the information expert principle from GRASP by assigning the responsibility
- * of total calculation to this service.
- * Additionally, it provides a method to complete the order, which empties the
- * client's shopping cart once the order is finalized.
+ * The OrderService class is responsible for finalizing a customer's order. It includes a method to
+ * calculate the total cost of the order, which follows the information expert principle from GRASP
+ * by assigning the responsibility of total calculation to this service. Additionally, it provides a
+ * method to complete the order, which empties the client's shopping cart once the order is
+ * finalized.
  */
 @Slf4j
 public class OrderService {
@@ -49,14 +48,12 @@ public class OrderService {
     this.cart = cart;
   }
 
-  /**
-   * Order.
-   */
+  /** Order. */
   public void order() {
     Double total = getTotal();
     if (!this.cart.isEmpty()) {
-      LOGGER.info("Client has chosen to order {} with total {}", cart,
-          String.format("%.2f", total));
+      LOGGER.info(
+          "Client has chosen to order {} with total {}", cart, String.format("%.2f", total));
       this.completeOrder();
     } else {
       LOGGER.info("Client's shopping cart is empty");
@@ -74,9 +71,7 @@ public class OrderService {
     return total[0];
   }
 
-  /**
-   * Complete order.
-   */
+  /** Complete order. */
   public void completeOrder() {
     this.cart.clear();
   }

session-facade/src/main/java/com/iluwatar/sessionfacade/PaymentService.java

@@ -29,19 +29,15 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
- * The PaymentService class is responsible for handling the selection and processing
- * of different payment methods. It provides functionality to select a payment method
- * (cash or credit card) and process the corresponding payment option. The class uses
- * logging to inform the client of the selected payment method.
- * It includes methods to:
- * - Select the payment method based on the client's choice.
- * - Process cash payments through the `cashPayment()` method.
- * - Process credit card payments through the `creditCardPayment()` method.
+ * The PaymentService class is responsible for handling the selection and processing of different
+ * payment methods. It provides functionality to select a payment method (cash or credit card) and
+ * process the corresponding payment option. The class uses logging to inform the client of the
+ * selected payment method. It includes methods to: - Select the payment method based on the
+ * client's choice. - Process cash payments through the `cashPayment()` method. - Process credit
+ * card payments through the `creditCardPayment()` method.
  */
 public class PaymentService {
-  /**
-   * The constant LOGGER.
-   */
+  /** The constant LOGGER. */
   public static Logger LOGGER = LoggerFactory.getLogger(PaymentService.class);
 
   /**
@@ -59,16 +55,12 @@ public class PaymentService {
     }
   }
 
-  /**
-   * Cash payment.
-   */
+  /** Cash payment. */
   public void cashPayment() {
     LOGGER.info("Client have chosen cash payment option");
   }
 
-  /**
-   * Credit card payment.
-   */
+  /** Credit card payment. */
   public void creditCardPayment() {
     LOGGER.info("Client have chosen credit card payment option");
   }

session-facade/src/main/java/com/iluwatar/sessionfacade/Product.java

@@ -25,14 +25,10 @@
 
 package com.iluwatar.sessionfacade;
 
-/**
- * The type Product.
- */
+/** The type Product. */
 public record Product(int id, String name, double price, String description) {
   @Override
   public String toString() {
     return "ID: " + id + "\nName: " + name + "\nPrice: $" + price + "\nDescription: " + description;
   }
 }
-
-

session-facade/src/main/java/com/iluwatar/sessionfacade/ProductCatalogService.java

@@ -28,10 +28,9 @@ package com.iluwatar.sessionfacade;
 import java.util.Map;
 
 /**
- * The type ProductCatalogService.
- * This class manages a catalog of products. It holds a map of products,
- * where each product is identified by a unique ID. The class
- * provides functionality to access and manage the products in the catalog.
+ * The type ProductCatalogService. This class manages a catalog of products. It holds a map of
+ * products, where each product is identified by a unique ID. The class provides functionality to
+ * access and manage the products in the catalog.
  */
 public class ProductCatalogService {
 

session-facade/src/main/java/com/iluwatar/sessionfacade/ShoppingFacade.java

@@ -29,21 +29,16 @@ import java.util.HashMap;
 import java.util.Map;
 import lombok.extern.slf4j.Slf4j;
 
-
 /**
- * The ShoppingFacade class provides a simplified interface for clients to interact with the shopping system.
- * It acts as a facade to handle operations related to a shopping cart, order processing, and payment.
- * Responsibilities:
- * - Add products to the shopping cart.
- * - Remove products from the shopping cart.
- * - Retrieve the current shopping cart.
- * - Finalize an order by calling the order service.
- * - Check if a payment is required based on the order total.
- * - Process payment using different payment methods (e.g., cash, credit card).
- * The ShoppingFacade class delegates operations to the following services:
- * - CartService: Manages the cart and product catalog.
- * - OrderService: Handles the order finalization process and calculation of the total.
- * - PaymentService: Handles the payment processing based on the selected payment method.
+ * The ShoppingFacade class provides a simplified interface for clients to interact with the
+ * shopping system. It acts as a facade to handle operations related to a shopping cart, order
+ * processing, and payment. Responsibilities: - Add products to the shopping cart. - Remove products
+ * from the shopping cart. - Retrieve the current shopping cart. - Finalize an order by calling the
+ * order service. - Check if a payment is required based on the order total. - Process payment using
+ * different payment methods (e.g., cash, credit card). The ShoppingFacade class delegates
+ * operations to the following services: - CartService: Manages the cart and product catalog. -
+ * OrderService: Handles the order finalization process and calculation of the total. -
+ * PaymentService: Handles the payment processing based on the selected payment method.
  */
 @Slf4j
 public class ShoppingFacade {
@@ -51,13 +46,15 @@ public class ShoppingFacade {
   private final OrderService orderService;
   private final PaymentService paymentService;
 
-  /**
-   * Instantiates a new Shopping facade.
-   */
+  /** Instantiates a new Shopping facade. */
   public ShoppingFacade() {
     Map<Integer, Product> productCatalog = new HashMap<>();
-    productCatalog.put(1, new Product(1, "Wireless Mouse", 25.99, "Ergonomic wireless mouse with USB receiver."));
-    productCatalog.put(2, new Product(2, "Gaming Keyboard", 79.99, "RGB mechanical gaming keyboard with programmable keys."));
+    productCatalog.put(
+        1, new Product(1, "Wireless Mouse", 25.99, "Ergonomic wireless mouse with USB receiver."));
+    productCatalog.put(
+        2,
+        new Product(
+            2, "Gaming Keyboard", 79.99, "RGB mechanical gaming keyboard with programmable keys."));
     Map<Integer, Product> cart = new HashMap<>();
     cartService = new CartService(cart, productCatalog);
     orderService = new OrderService(cart);
@@ -91,9 +88,7 @@ public class ShoppingFacade {
     this.cartService.removeFromCart(productId);
   }
 
-  /**
-   * Order.
-   */
+  /** Order. */
   public void order() {
     this.orderService.order();
   }

session-facade/src/test/java/com/iluwatar/sessionfacade/AppTest.java

@@ -26,17 +26,12 @@ package com.iluwatar.sessionfacade;
 
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
-/**
- * The type App test.
- */
+/** The type App test. */
 public class AppTest {
 
-  /**
-   * Should execute application without exception.
-   */
+  /** Should execute application without exception. */
   @org.junit.jupiter.api.Test
   void shouldExecuteApplicationWithoutException() {
-    assertDoesNotThrow(() -> App.main(new String[]{}));
+    assertDoesNotThrow(() -> App.main(new String[] {}));
   }
-
 }

session-facade/src/test/java/com/iluwatar/sessionfacade/CartServiceTest.java

@@ -24,43 +24,34 @@
  */
 package com.iluwatar.sessionfacade;
 
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.HashMap;
+import java.util.Map;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.MockitoAnnotations;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * The type Cart service test.
- */
+/** The type Cart service test. */
 @Slf4j
 class CartServiceTest {
 
   private CartService cartService;
-  private Map<Integer,Product> cart;
+  private Map<Integer, Product> cart;
 
-  /**
-   * Sets up.
-   */
+  /** Sets up. */
   @BeforeEach
   void setUp() {
     MockitoAnnotations.openMocks(this);
     cart = new HashMap<>();
-    Map<Integer,Product> productCatalog = new HashMap<>();
-    productCatalog.put(1,new Product(1, "Product A", 2.0, "any description"));
-    productCatalog.put(2,new Product(2, "Product B", 300.0, "a watch"));
+    Map<Integer, Product> productCatalog = new HashMap<>();
+    productCatalog.put(1, new Product(1, "Product A", 2.0, "any description"));
+    productCatalog.put(2, new Product(2, "Product B", 300.0, "a watch"));
     cartService = new CartService(cart, productCatalog);
   }
 
-  /**
-   * Test add to cart.
-   */
+  /** Test add to cart. */
   @Test
   void testAddToCart() {
     cartService.addToCart(1);
@@ -68,9 +59,7 @@ class CartServiceTest {
     assertEquals("Product A", cart.get(1).name());
   }
 
-  /**
-   * Test remove from cart.
-   */
+  /** Test remove from cart. */
   @Test
   void testRemoveFromCart() {
     cartService.addToCart(1);
@@ -79,18 +68,14 @@ class CartServiceTest {
     assertTrue(cart.isEmpty());
   }
 
-  /**
-   * Test add to cart with invalid product id.
-   */
+  /** Test add to cart with invalid product id. */
   @Test
   void testAddToCartWithInvalidProductId() {
     cartService.addToCart(999);
     assertTrue(cart.isEmpty());
   }
 
-  /**
-   * Test remove from cart with invalid product id.
-   */
+  /** Test remove from cart with invalid product id. */
   @Test
   void testRemoveFromCartWithInvalidProductId() {
     cartService.removeFromCart(999);

session-facade/src/test/java/com/iluwatar/sessionfacade/PaymentServiceTest.java

@@ -24,23 +24,19 @@
  */
 package com.iluwatar.sessionfacade;
 
+import static org.mockito.Mockito.*;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 
-import static org.mockito.Mockito.*;
-
-/**
- * The type Payment service test.
- */
+/** The type Payment service test. */
 class PaymentServiceTest {
   private PaymentService paymentService;
   private OrderService orderService;
   private Logger mockLogger;
 
-  /**
-   * Sets up.
-   */
+  /** Sets up. */
   @BeforeEach
   void setUp() {
     paymentService = new PaymentService();
@@ -48,9 +44,7 @@ class PaymentServiceTest {
     paymentService.LOGGER = mockLogger;
   }
 
-  /**
-   * Test select cash payment method.
-   */
+  /** Test select cash payment method. */
   @Test
   void testSelectCashPaymentMethod() {
     String method = "cash";
@@ -58,9 +52,7 @@ class PaymentServiceTest {
     verify(mockLogger).info("Client have chosen cash payment option");
   }
 
-  /**
-   * Test select credit card payment method.
-   */
+  /** Test select credit card payment method. */
   @Test
   void testSelectCreditCardPaymentMethod() {
     String method = "credit";
@@ -68,9 +60,7 @@ class PaymentServiceTest {
     verify(mockLogger).info("Client have chosen credit card payment option");
   }
 
-  /**
-   * Test select unspecified payment method.
-   */
+  /** Test select unspecified payment method. */
   @Test
   void testSelectUnspecifiedPaymentMethod() {
     String method = "cheque";

session-facade/src/test/java/com/iluwatar/sessionfacade/ProductTest.java

@@ -24,33 +24,27 @@
  */
 package com.iluwatar.sessionfacade;
 
-import org.junit.jupiter.api.Test;
-
 import static org.junit.jupiter.api.Assertions.*;
 
-/**
- * The type Product test.
- */
+import org.junit.jupiter.api.Test;
+
+/** The type Product test. */
 public class ProductTest {
-  /**
-   * Test product creation.
-   */
+  /** Test product creation. */
   @Test
   public void testProductCreation() {
     int id = 1;
     String name = "Product A";
     double price = 200.0;
     String description = "a description";
-    Product product = new Product(id,name,price,description);
+    Product product = new Product(id, name, price, description);
     assertEquals(id, product.id());
     assertEquals(name, product.name());
     assertEquals(price, product.price());
     assertEquals(description, product.description());
   }
 
-  /**
-   * Test equals and hash code.
-   */
+  /** Test equals and hash code. */
   @Test
   public void testEqualsAndHashCode() {
     Product product1 = new Product(1, "Product A", 99.99, "a description");
@@ -63,9 +57,7 @@ public class ProductTest {
     assertNotEquals(product1.hashCode(), product3.hashCode());
   }
 
-  /**
-   * Test to string.
-   */
+  /** Test to string. */
   @Test
   public void testToString() {
     Product product = new Product(1, "Product A", 99.99, "a description");
@@ -73,5 +65,4 @@ public class ProductTest {
     assertTrue(toStringResult.contains("Product A"));
     assertTrue(toStringResult.contains("99.99"));
   }
-
 }

session-facade/src/test/java/com/iluwatar/sessionfacade/ShoppingFacadeTest.java

@@ -24,17 +24,14 @@
  */
 package com.iluwatar.sessionfacade;
 
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import java.util.List;
-import java.util.Map;
-
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-/**
- * Unit tests for ShoppingFacade.
- */
+import java.util.Map;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/** Unit tests for ShoppingFacade. */
 class ShoppingFacadeTest {
 
   private ShoppingFacade shoppingFacade;
@@ -48,10 +45,14 @@ class ShoppingFacadeTest {
   void testAddToCart() {
     shoppingFacade.addToCart(1);
     shoppingFacade.addToCart(2);
-    Map<Integer,Product> cart = shoppingFacade.getCart();
+    Map<Integer, Product> cart = shoppingFacade.getCart();
     assertEquals(2, cart.size(), "Cart should contain two items.");
-    assertEquals("Wireless Mouse", cart.get(1).name(), "First item in the cart should be 'Wireless Mouse'.");
-    assertEquals("Gaming Keyboard", cart.get(2).name(), "Second item in the cart should be 'Gaming Keyboard'.");
+    assertEquals(
+        "Wireless Mouse", cart.get(1).name(), "First item in the cart should be 'Wireless Mouse'.");
+    assertEquals(
+        "Gaming Keyboard",
+        cart.get(2).name(),
+        "Second item in the cart should be 'Gaming Keyboard'.");
   }
 
   @Test
@@ -59,9 +60,10 @@ class ShoppingFacadeTest {
     shoppingFacade.addToCart(1);
     shoppingFacade.addToCart(2);
     shoppingFacade.removeFromCart(1);
-    Map<Integer,Product> cart = shoppingFacade.getCart();
+    Map<Integer, Product> cart = shoppingFacade.getCart();
     assertEquals(1, cart.size(), "Cart should contain one item after removal.");
-    assertEquals("Gaming Keyboard", cart.get(2).name(), "Remaining item should be 'Gaming Keyboard'.");
+    assertEquals(
+        "Gaming Keyboard", cart.get(2).name(), "Remaining item should be 'Gaming Keyboard'.");
   }
 
   @Test