test: Add unit test dao-factory

Author: letdtcode

dao-factory/README.md

@@ -0,0 +1,27 @@
+## Also known as
+
+
+
+## Intent of Data Access Object Factory Design Pattern
+
+
+## Detailed Explanation of Data Access Object Factory Pattern with Real-World Examples
+
+Class diagram
+
+![Data Access Object Factory class diagram](./etc/dao-factory.png "Data Access Object Factory class diagram")
+
+## Programmatic Example of Data Access Object Factory in Java
+
+## When to Use the Data Access Object Factory Pattern in Java
+
+## Data Access Object Factory Pattern Java Tutorials
+
+
+## Benefits and Trade-offs of Data Access Object Factory Pattern
+
+## Real-World Applications of Data Access Object Factory Pattern in Java
+
+## Related Java Design Patterns
+
+## References and Credits

dao-factory/etc/dao-factory.puml

@@ -0,0 +1,78 @@
+@startuml
+package com.iluwatar.daofactory {
+    class App {
+        {static} void main(String[] args)
+        {static} <T> void performCreateCustomer(CustomerDAO<T> customerDAO, \n                                                              List<Customer<T>> customerList)
+        {static} <T> void performUpdateCustomer(CustomerDAO<T> customerDAO, \n                                                               Customer<T> customerUpdate)
+        {static} <T> void performDeleteCustomer(CustomerDAO<T> customerDAO, \n                                                              T id)
+        {static} void deleteSchema(CustomerDAO customerDAO)
+    }
+
+    class Customer<T> {
+        T id
+        String name
+    }
+
+    interface CustomerDAO<ID> {
+        void save(Customer<ID> customer)
+        void update(Customer<ID> customer)
+        void delete(ID id)
+        List<Customer<ID>> findAll()
+        Optional<Customer<ID>> findById(ID id)
+        void deleteSchema()
+    }
+
+    abstract class DAOFactory {
+    {static} DAOFactory getDataSource(DataSourceType dataType)
+    {abstract} CustomerDAO createCustomerDAO()
+    }
+
+    enum DataSourceType {
+        H2
+        Mongo
+        FlatFile
+    }
+
+    class FlatFileCustomerDAO implements CustomerDAO<Long> {
+            void save(Customer<Long> customer)
+            void update(Customer<Long> customer)
+            void delete(Long id)
+            List<Customer<Long>> findAll()
+            Optional<Customer<Long>> findById(Long id)
+            void deleteSchema()
+    }
+
+    class H2CustomerDAO implements CustomerDAO<Long> {
+                    void save(Customer<Long> customer)
+                    void update(Customer<Long> customer)
+                    void delete(Long id)
+                    List<Customer<Long>> findAll()
+                    Optional<Customer<Long>> findById(Long id)
+                    void deleteSchema()
+    }
+
+    class FlatFileDataSourceFactory extends DAOFactory {
+        CustomerDAO createCustomerDAO()
+    }
+
+    class H2DataSourceFactory extends DAOFactory {
+        CustomerDAO createCustomerDAO()
+    }
+
+    class MongoCustomerDAO implements CustomerDAO<ObjectId> {
+                    void save(Customer<ObjectId> customer)
+                    void update(Customer<ObjectId> customer)
+                    void delete(ObjectId id)
+                    List<Customer<ObjectId>> findAll()
+                    Optional<Customer<ObjectId>> findById(ObjectId id)
+                    void deleteSchema()
+    }
+    class MongoDataSourceFactory extends DAOFactory {
+        CustomerDAO createCustomerDAO()
+    }
+
+    DataSourceType ..+ DAOFactory
+    DAOFactory ..+ App
+    App --> Customer
+ }
+@enduml

dao-factory/pom.xml

@@ -31,10 +31,10 @@
             <groupId>ch.qos.logback</groupId>
             <artifactId>logback-classic</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.mongodb</groupId>
-            <artifactId>bson</artifactId>
-        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>org.mongodb</groupId>-->
+<!--            <artifactId>bson</artifactId>-->
+<!--        </dependency>-->
         <dependency>
             <groupId>org.mongodb</groupId>
             <artifactId>mongodb-driver-legacy</artifactId>
@@ -43,6 +43,18 @@
             <groupId>com.google.code.gson</groupId>
             <artifactId>gson</artifactId>
         </dependency>
+
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 </project>

dao-factory/src/main/java/com/iluwatar/daofactory/App.java

@@ -1,109 +1,99 @@
 package com.iluwatar.daofactory;
 
-import java.sql.SQLException;
 import java.util.List;
 import lombok.extern.slf4j.Slf4j;
 import org.bson.types.ObjectId;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
-/**
- * Created by: IntelliJ IDEA
- * User      : dthanh
- * Date      : 16/04/2025
- * Time      : 23:08
- * Filename  : ${NAME}
- */
 @Slf4j
 public class App {
 
-  private static final Logger logger = LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
 
-
-
-  public static void main(String[] args) throws SQLException {
-    final var h2DAO = DAOFactory.getDataSource(DataSourceEnum.H2);
-    final var mongoDAO = DAOFactory.getDataSource(DataSourceEnum.Mongo);
-    final var flatFileDAO = DAOFactory.getDataSource(DataSourceEnum.FlatFile);
-
-    final var h2CustomerDAO = h2DAO.getCustomerDAO();
-    final var mongoCustomerDAO = mongoDAO.getCustomerDAO();
-    final var flatFileCustomerDAO = flatFileDAO.getCustomerDAO();
+  public static void main(String[] args) {
+    var daoFactory = DAOFactory.getDataSource(DataSourceType.H2);
+    var customerDAO = daoFactory.createCustomerDAO();
 
     // Perform CRUD H2 Database
+    if (customerDAO instanceof H2CustomerDAO h2CustomerDAO) {
+      h2CustomerDAO.deleteSchema();
+      h2CustomerDAO.createSchema();
+    }
     Customer<Long> customerInmemory1 = new Customer<>(1L, "Green");
     Customer<Long> customerInmemory2 = new Customer<>(2L, "Red");
     Customer<Long> customerInmemory3 = new Customer<>(3L, "Blue");
     Customer<Long> customerUpdateInmemory = new Customer<>(1L, "Yellow");
 
     LOGGER.debug("H2 - Create customer");
-    performCreateCustomer(h2CustomerDAO,
+    performCreateCustomer(customerDAO,
         List.of(customerInmemory1, customerInmemory2, customerInmemory3));
     LOGGER.debug("H2 - Update customer");
-    performUpdateCustomer(h2CustomerDAO, customerUpdateInmemory);
+    performUpdateCustomer(customerDAO, customerUpdateInmemory);
     LOGGER.debug("H2 - Delete customer");
-    performDeleteCustomer(h2CustomerDAO, 3L);
-    deleteSchema(h2CustomerDAO);
+    performDeleteCustomer(customerDAO, 3L);
+    deleteSchema(customerDAO);
 
     // Perform CRUD MongoDb
+    daoFactory = DAOFactory.getDataSource(DataSourceType.Mongo);
+    customerDAO = daoFactory.createCustomerDAO();
     ObjectId idCustomerMongo1 = new ObjectId();
     ObjectId idCustomerMongo2 = new ObjectId();
     Customer<ObjectId> customer4 = new Customer<>(idCustomerMongo1, "Masca");
     Customer<ObjectId> customer5 = new Customer<>(idCustomerMongo2, "Elliot");
     Customer<ObjectId> customerUpdateMongo = new Customer<>(idCustomerMongo2, "Henry");
 
     LOGGER.debug("Mongo - Create customer");
-    performCreateCustomer(mongoCustomerDAO, List.of(customer4, customer5));
+    performCreateCustomer(customerDAO, List.of(customer4, customer5));
     LOGGER.debug("Mongo - Update customer");
-    performUpdateCustomer(mongoCustomerDAO, customerUpdateMongo);
+    performUpdateCustomer(customerDAO, customerUpdateMongo);
     LOGGER.debug("Mongo - Delete customer");
-    performDeleteCustomer(mongoCustomerDAO, idCustomerMongo2);
-    deleteSchema(mongoCustomerDAO);
+    performDeleteCustomer(customerDAO, idCustomerMongo2);
+    deleteSchema(customerDAO);
 
     // Perform CRUD Flat file
+    daoFactory = DAOFactory.getDataSource(DataSourceType.FlatFile);
+    customerDAO = daoFactory.createCustomerDAO();
     Customer<Long> customerFlatFile1 = new Customer<>(1L, "Duc");
     Customer<Long> customerFlatFile2 = new Customer<>(2L, "Quang");
     Customer<Long> customerFlatFile3 = new Customer<>(3L, "Nhat");
     Customer<Long> customerUpdateFlatFile = new Customer<>(1L, "Thanh");
     LOGGER.debug("Flat file - Create customer");
-    performCreateCustomer(flatFileCustomerDAO,
+    performCreateCustomer(customerDAO,
         List.of(customerFlatFile1, customerFlatFile2, customerFlatFile3));
     LOGGER.debug("Flat file - Update customer");
-    performUpdateCustomer(flatFileCustomerDAO, customerUpdateFlatFile);
+    performUpdateCustomer(customerDAO, customerUpdateFlatFile);
     LOGGER.debug("Flat file - Delete customer");
-    performDeleteCustomer(flatFileCustomerDAO, 3L);
-    deleteSchema(flatFileCustomerDAO);
+    performDeleteCustomer(customerDAO, 3L);
+    deleteSchema(customerDAO);
   }
 
   public static void deleteSchema(CustomerDAO<?> customerDAO) {
     customerDAO.deleteSchema();
   }
 
-  public static <ID> void performCreateCustomer(CustomerDAO<ID> customerDAO,
-                                                List<Customer<ID>> customerList) {
-    for (Customer<ID> customer : customerList) {
+  public static <T> void performCreateCustomer(CustomerDAO<T> customerDAO,
+                                               List<Customer<T>> customerList) {
+    for (Customer<T> customer : customerList) {
       customerDAO.save(customer);
     }
-    List<Customer<ID>> customers = customerDAO.findAll();
-    for (Customer<ID> customer : customers) {
+    List<Customer<T>> customers = customerDAO.findAll();
+    for (Customer<T> customer : customers) {
       LOGGER.debug(customer.toString());
     }
   }
 
-  public static <ID> void performUpdateCustomer(CustomerDAO<ID> customerDAO,
-                                                Customer<ID> customerUpdate) {
+  public static <T> void performUpdateCustomer(CustomerDAO<T> customerDAO,
+                                               Customer<T> customerUpdate) {
     customerDAO.update(customerUpdate);
-    List<Customer<ID>> customers = customerDAO.findAll();
-    for (Customer<ID> customer : customers) {
-      LOGGER.error(customer.toString());
+    List<Customer<T>> customers = customerDAO.findAll();
+    for (Customer<T> customer : customers) {
+      LOGGER.debug(customer.toString());
     }
   }
 
-  public static <ID> void performDeleteCustomer(CustomerDAO<ID> customerDAO,
-                                                ID customerId) {
+  public static <T> void performDeleteCustomer(CustomerDAO<T> customerDAO,
+                                               T customerId) {
     customerDAO.delete(customerId);
-    List<Customer<ID>> customers = customerDAO.findAll();
-    for (Customer<ID> customer : customers) {
+    List<Customer<T>> customers = customerDAO.findAll();
+    for (Customer<T> customer : customers) {
       LOGGER.debug(customer.toString());
     }
   }

dao-factory/src/main/java/com/iluwatar/daofactory/Customer.java

@@ -8,11 +8,9 @@
 import lombok.ToString;
 
 /**
- * Created by: IntelliJ IDEA
- * User      : dthanh
- * Date      : 16/04/2025
- * Time      : 23:22
- * Filename  : Customer
+ * A customer generic POJO that represents the data that can be stored in any supported data source.
+ * This class is designed t work with various ID types (e.g., Long, String, or ObjectId) through generic,
+ * making it adaptable to different persistence system.
  */
 @Getter
 @Setter

dao-factory/src/main/java/com/iluwatar/daofactory/CustomerDAO.java

@@ -4,22 +4,57 @@
 import java.util.Optional;
 
 /**
- * Created by: IntelliJ IDEA
- * User      : dthanh
- * Date      : 16/04/2025
- * Time      : 23:16
- * Filename  : CustomerDAO
+ * The Data Access Object (DAO) pattern provides an abstraction layer between the application
+ * and the database. It encapsulates data access logic, allowing the application to work
+ * with domain objects instead of direct database operations.
+ *
+ * <p>Implementations handle specific storage mechanisms (e.g., in-memory, databases)
+ * while keeping client code unchanged.
+ *
+ * @see H2CustomerDAO
+ * @see MongoCustomerDAO
+ * @see FlatFileCustomerDAO
  */
-public interface CustomerDAO<ID> {
-  void save(Customer<ID> customer);
+public interface CustomerDAO<T> {
+  /**
+   * Persist the given customer
+   *
+   * @param customer the customer to persist
+   */
+  void save(Customer<T> customer);
 
-  void update(Customer<ID> customer);
+  /**
+   * Update the given customer
+   *
+   * @param customer the customer to update
+   */
+  void update(Customer<T> customer);
 
-  void delete(ID id);
+  /**
+   * Delete the customer with the given id
+   *
+   * @param id the id of the customer to delete
+   */
+  void delete(T id);
 
-  List<Customer<ID>> findAll();
+  /**
+   * Find all customers
+   *
+   * @return a list of customers
+   */
+  List<Customer<T>> findAll();
 
-  Optional<Customer<ID>> findById(ID id);
+  /**
+   * Find the customer with the given id
+   *
+   * @param id the id of the customer to find
+   * @return the customer with the given id
+   */
+  Optional<Customer<T>> findById(T id);
 
+  /**
+   * Delete the customer schema. After executing the statements,
+   * this function will be called to clean up the data and delete the records.
+   */
   void deleteSchema();
 }