refactor unit of work

* docs: update README.md [skip ci]

* docs: update .all-contributorsrc [skip ci]

Co-authored-by: allcontributors[bot] <46447321+allcontributors[bot]@users.noreply.github.com>

.all-contributorsrc

@@ -1776,6 +1776,15 @@
       "contributions": [
         "code"
       ]
+    },
+    {
+      "login": "castleKing1997",
+      "name": "DragonDreamer",
+      "avatar_url": "https://avatars.githubusercontent.com/u/35420129?v=4",
+      "profile": "http://rosaecrucis.cn",
+      "contributions": [
+        "code"
+      ]
     }
   ],
   "contributorsPerLine": 7,

README.md

@@ -10,7 +10,7 @@
 [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=iluwatar_java-design-patterns&metric=coverage)](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns)
 [![Join the chat at https://gitter.im/iluwatar/java-design-patterns](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/iluwatar/java-design-patterns?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-[![All Contributors](https://img.shields.io/badge/all_contributors-195-orange.svg?style=flat-square)](#contributors-)
+[![All Contributors](https://img.shields.io/badge/all_contributors-196-orange.svg?style=flat-square)](#contributors-)
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 
 <br/>
@@ -325,6 +325,7 @@ This project is licensed under the terms of the MIT license.
     <td align="center"><a href="https://github.com/interactwithankush"><img src="https://avatars.githubusercontent.com/u/18613127?v=4?s=100" width="100px;" alt=""/><br /><sub><b>interactwithankush</b></sub></a><br /><a href="https://github.com/iluwatar/java-design-patterns/commits?author=interactwithankush" title="Code">💻</a></td>
     <td align="center"><a href="https://github.com/yuhangbin"><img src="https://avatars.githubusercontent.com/u/17566866?v=4?s=100" width="100px;" alt=""/><br /><sub><b>CharlieYu</b></sub></a><br /><a href="https://github.com/iluwatar/java-design-patterns/commits?author=yuhangbin" title="Code">💻</a></td>
     <td align="center"><a href="https://github.com/Leisterbecker"><img src="https://avatars.githubusercontent.com/u/20650323?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Leisterbecker</b></sub></a><br /><a href="https://github.com/iluwatar/java-design-patterns/commits?author=Leisterbecker" title="Code">💻</a></td>
+    <td align="center"><a href="http://rosaecrucis.cn"><img src="https://avatars.githubusercontent.com/u/35420129?v=4?s=100" width="100px;" alt=""/><br /><sub><b>DragonDreamer</b></sub></a><br /><a href="https://github.com/iluwatar/java-design-patterns/commits?author=castleKing1997" title="Code">💻</a></td>
   </tr>
 </table>
 

metadata-mapping/README.md

@@ -0,0 +1,182 @@
+---
+layout: pattern
+title: Metadata Mapping
+folder: metadata-mapping
+permalink: /patterns/metadata-mapping/
+categories: Architectural
+language: en
+tags:
+ - Data access
+---
+
+## Intent
+
+Holds details of object-relational mapping in the metadata.
+
+## Explanation
+
+Real world example
+
+> Hibernate ORM Tool uses Metadata Mapping Pattern to specify the mapping between classes and tables either using XML or annotations in code. 
+
+In plain words
+
+> Metadata Mapping specifies the mapping between classes and tables so that we could treat a table of any database like a Java class.
+
+Wikipedia says
+
+> Create a "virtual [object database](https://en.wikipedia.org/wiki/Object_database)" that can be used from within the programming language.
+
+**Programmatic Example**
+
+We give an example about visiting the information of `USER` table in `h2` database. Firstly, we create `USER` table with `h2`:
+
+```java
+@Slf4j
+public class DatabaseUtil {
+  private static final String DB_URL = "jdbc:h2:mem:metamapping";
+  private static final String CREATE_SCHEMA_SQL = "DROP TABLE IF EXISTS `user`;"
+      + "CREATE TABLE `user` (\n"
+      + "  `id` int(11) NOT NULL AUTO_INCREMENT,\n"
+      + "  `username` varchar(255) NOT NULL,\n"
+      + "  `password` varchar(255) NOT NULL,\n"
+      + "  PRIMARY KEY (`id`)\n"
+      + ");";
+    
+  /**
+   * Create database.
+   */
+  static {
+    LOGGER.info("create h2 database");
+    var source = new JdbcDataSource();
+    source.setURL(DB_URL);
+    try (var statement = source.getConnection().createStatement()) {
+      statement.execute(CREATE_SCHEMA_SQL);
+    } catch (SQLException e) {
+      LOGGER.error("unable to create h2 data source", e);
+    }
+  }
+}
+```
+
+Correspondingly, here's the basic `User` entity.
+
+```java
+@Setter
+@Getter
+@ToString
+public class User {
+  private Integer id;
+  private String username;
+  private String password;
+    
+  /**
+   * Get a user.
+   * @param username user name
+   * @param password user password
+   */
+  public User(String username, String password) {
+    this.username = username;
+    this.password = password;
+  }
+}
+```
+
+Then we write a `xml` file to show the mapping between the table and the object:
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE hibernate-mapping PUBLIC
+    "-//Hibernate/Hibernate Mapping DTD//EN"
+    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
+
+<hibernate-mapping>
+  <class name="com.iluwatar.metamapping.model.User" table="user">
+    <id name="id" type="java.lang.Integer" column="id">
+      <generator class="native"/>
+    </id>
+    <property name="username" column="username" type="java.lang.String"/>
+    <property name="password" column="password" type="java.lang.String"/>
+  </class>
+</hibernate-mapping>
+```
+
+We use `Hibernate` to resolve the mapping and connect to our database, here's its configuration:
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE hibernate-configuration PUBLIC
+    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
+<hibernate-configuration>
+  <session-factory>
+    <!-- JDBC Database connection settings -->
+    <property name="connection.url">jdbc:h2:mem:metamapping</property>
+    <property name="connection.driver_class">org.h2.Driver</property>
+    <!-- JDBC connection pool settings ... using built-in test pool -->
+    <property name="connection.pool_size">1</property>
+    <!-- Select our SQL dialect -->
+    <property name="dialect">org.hibernate.dialect.H2Dialect</property>
+    <!-- Echo the SQL to stdout -->
+    <property name="show_sql">false</property>
+    <!-- Drop and re-create the database schema on startup -->
+    <property name="hbm2ddl.auto">create-drop</property>
+    <mapping resource="com/iluwatar/metamapping/model/User.hbm.xml" />
+  </session-factory>
+</hibernate-configuration>
+```
+
+Then we can get access to the table just like an object with `Hibernate`, here's some CRUDs:
+
+```java
+@Slf4j
+public class UserService {
+  private static final SessionFactory factory = HibernateUtil.getSessionFactory();
+
+  /**
+   * List all users.
+   * @return list of users
+   */
+  public List<User> listUser() {
+    LOGGER.info("list all users.");
+    List<User> users = new ArrayList<>();
+    try (var session = factory.openSession()) {
+      var tx = session.beginTransaction();
+      List<User> userIter = session.createQuery("FROM User").list();
+      for (var iterator = userIter.iterator(); iterator.hasNext();) {
+        users.add(iterator.next());
+      }
+      tx.commit();
+    } catch (HibernateException e) {
+      LOGGER.debug("fail to get users", e);
+    }
+    return users;
+  }
+  
+  // other CRUDs ->
+  ...
+    
+  public void close() {
+    HibernateUtil.shutdown();
+  }
+}
+```
+
+## Class diagram
+
+![metamapping](etc/metamapping.png)
+
+## Applicability
+
+Use the Metadata Mapping when:
+
+- you want reduce the amount of work needed to handle database mapping.
+
+## Known uses
+
+[Hibernate](https://hibernate.org/), [EclipseLink](https://www.eclipse.org/eclipselink/), [MyBatis](https://blog.mybatis.org/)......
+
+## Credits
+
+- [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=48d37c67fb3d845b802fa9b619ad8f31)
+

metadata-mapping/etc/metamapping.puml

@@ -0,0 +1,32 @@
+@startuml
+interface com.iluwatar.metamapping.service.UserService {
++ List<User> listUser()
++ int createUser(User)
++ void updateUser(Integer,User)
++ void deleteUser(Integer)
++ User getUser(Integer)
++ void close()
+}
+class com.iluwatar.metamapping.utils.DatabaseUtil {
++ {static} void createDataSource()
+}
+class com.iluwatar.metamapping.model.User {
+- Integer id
+- String username
+- String password
++ User(String username, String password)
+}
+class com.iluwatar.metamapping.utils.HibernateUtil {
++ {static} SessionFactory getSessionFactory()
++ {static} void shutdown()
+}
+class com.iluwatar.metamapping.App {
++ {static} void main(String[])
++ {static} List<User> generateSampleUsers()
+}
+
+com.iluwatar.metamapping.service.UserService <.. com.iluwatar.metamapping.App
+com.iluwatar.metamapping.model.User <.. com.iluwatar.metamapping.service.UserService
+com.iluwatar.metamapping.utils.HibernateUtil <.. com.iluwatar.metamapping.service.UserService
+com.iluwatar.metamapping.utils.DatabaseUtil <-- com.iluwatar.metamapping.utils.HibernateUtil
+@enduml

metadata-mapping/pom.xml

@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+  The MIT License
+  Copyright © 2014-2021 Ilkka Seppälä
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <parent>
+    <artifactId>java-design-patterns</artifactId>
+    <groupId>com.iluwatar</groupId>
+    <version>1.26.0-SNAPSHOT</version>
+  </parent>
+  <modelVersion>4.0.0</modelVersion>
+
+  <artifactId>metadata-mapping</artifactId>
+  <dependencies>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-engine</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.h2database</groupId>
+      <artifactId>h2</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.hibernate</groupId>
+      <artifactId>hibernate-core</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>com.h2database</groupId>
+      <artifactId>h2</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>javax.xml.bind</groupId>
+      <artifactId>jaxb-api</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>com.sun.xml.bind</groupId>
+      <artifactId>jaxb-impl</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>com.sun.istack</groupId>
+      <artifactId>istack-commons-runtime</artifactId>
+    </dependency>
+  </dependencies>
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-assembly-plugin</artifactId>
+        <executions>
+          <execution>
+            <configuration>
+              <archive>
+                <manifest>
+                  <mainClass>com.iluwatar.metamapping.App</mainClass>
+                </manifest>
+              </archive>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>

metadata-mapping/src/main/java/com/iluwatar/metamapping/App.java

@@ -0,0 +1,72 @@
+package com.iluwatar.metamapping;
+
+import com.iluwatar.metamapping.model.User;
+import com.iluwatar.metamapping.service.UserService;
+import com.iluwatar.metamapping.utils.DatabaseUtil;
+import java.util.List;
+import lombok.extern.slf4j.Slf4j;
+import org.hibernate.service.ServiceRegistry;
+
+/**
+ * Metadata Mapping specifies the mapping
+ * between classes and tables so that
+ * we could treat a table of any database like a Java class.
+ *
+ * <p>With hibernate, we achieve list/create/update/delete/get operations:
+ * 1)Create the H2 Database in {@link DatabaseUtil}.
+ * 2)Hibernate resolve hibernate.cfg.xml and generate service like save/list/get/delete.
+ *    For learning metadata mapping pattern, we go deeper into Hibernate here:
+ * a)read properties from hibernate.cfg.xml and mapping from *.hbm.xml
+ * b)create session factory to generate session interacting with database
+ * c)generate session with factory pattern
+ * d)create query object or use basic api with session,
+ *      hibernate will convert all query to database query according to metadata
+ * 3)We encapsulate hibernate service in {@link UserService} for our use.
+ * @see org.hibernate.cfg.Configuration#configure(String)
+ * @see org.hibernate.cfg.Configuration#buildSessionFactory(ServiceRegistry)
+ * @see org.hibernate.internal.SessionFactoryImpl#openSession()
+ */
+@Slf4j
+public class App {
+  /**
+   * Program entry point.
+   *
+   * @param args command line args.
+   * @throws Exception if any error occurs.
+   */
+  public static void main(String[] args)  throws Exception {
+    // get service
+    var userService = new UserService();
+    // use create service to add users
+    for (var user: generateSampleUsers()) {
+      var id = userService.createUser(user);
+      LOGGER.info("Add user" + user + "at" + id + ".");
+    }
+    // use list service to get users
+    var users = userService.listUser();
+    LOGGER.info(String.valueOf(users));
+    // use get service to get a user
+    var user = userService.getUser(1);
+    LOGGER.info(String.valueOf(user));
+    // change password of user 1
+    user.setPassword("new123");
+    // use update service to update user 1
+    userService.updateUser(1, user);
+    // use delete service to delete user 2
+    userService.deleteUser(2);
+    // close service
+    userService.close();
+  }
+
+  /**
+   * Generate users.
+   *
+   * @return list of users.
+   */
+  public static List<User> generateSampleUsers() {
+    final var user1 = new User("ZhangSan", "zhs123");
+    final var user2 = new User("LiSi", "ls123");
+    final var user3 = new User("WangWu", "ww123");
+    return List.of(user1, user2, user3);
+  }
+}

metadata-mapping/src/main/java/com/iluwatar/metamapping/model/User.java

@@ -0,0 +1,29 @@
+package com.iluwatar.metamapping.model;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+/**
+ * User Entity.
+ */
+@Setter
+@Getter
+@ToString
+public class User {
+  private Integer id;
+  private String username;
+  private String password;
+
+  public User() {}
+
+  /**
+   * Get a user.
+   * @param username user name
+   * @param password user password
+   */
+  public User(String username, String password) {
+    this.username = username;
+    this.password = password;
+  }
+}

metadata-mapping/src/main/java/com/iluwatar/metamapping/service/UserService.java

@@ -0,0 +1,114 @@
+package com.iluwatar.metamapping.service;
+
+import com.iluwatar.metamapping.model.User;
+import com.iluwatar.metamapping.utils.HibernateUtil;
+import java.util.ArrayList;
+import java.util.List;
+import lombok.extern.slf4j.Slf4j;
+import org.hibernate.HibernateException;
+import org.hibernate.SessionFactory;
+
+/**
+ * Service layer for user.
+ */
+@Slf4j
+public class UserService {
+  private static final SessionFactory factory = HibernateUtil.getSessionFactory();
+
+  /**
+   * List all users.
+   * @return list of users
+   */
+  public List<User> listUser() {
+    LOGGER.info("list all users.");
+    List<User> users = new ArrayList<>();
+    try (var session = factory.openSession()) {
+      var tx = session.beginTransaction();
+      List<User> userIter = session.createQuery("FROM User").list();
+      for (var iterator = userIter.iterator(); iterator.hasNext();) {
+        users.add(iterator.next());
+      }
+      tx.commit();
+    } catch (HibernateException e) {
+      LOGGER.debug("fail to get users", e);
+    }
+    return users;
+  }
+
+  /**
+   * Add a user.
+   * @param user user entity
+   * @return user id
+   */
+  public int createUser(User user) {
+    LOGGER.info("create user: " + user.getUsername());
+    var id = -1;
+    try (var session = factory.openSession()) {
+      var tx = session.beginTransaction();
+      id = (Integer) session.save(user);
+      tx.commit();
+    } catch (HibernateException e) {
+      LOGGER.debug("fail to create user", e);
+    }
+    LOGGER.info("create user " + user.getUsername() + " at " + id);
+    return id;
+  }
+
+  /**
+   * Update user.
+   * @param id user id
+   * @param user new user entity
+   */
+  public void updateUser(Integer id, User user) {
+    LOGGER.info("update user at " + id);
+    try (var session = factory.openSession()) {
+      var tx = session.beginTransaction();
+      user.setId(id);
+      session.update(user);
+      tx.commit();
+    } catch (HibernateException e) {
+      LOGGER.debug("fail to update user", e);
+    }
+  }
+
+  /**
+   * Delete user.
+   * @param id user id
+   */
+  public void deleteUser(Integer id) {
+    LOGGER.info("delete user at: " + id);
+    try (var session = factory.openSession()) {
+      var tx = session.beginTransaction();
+      var user = session.get(User.class, id);
+      session.delete(user);
+      tx.commit();
+    } catch (HibernateException e) {
+      LOGGER.debug("fail to delete user", e);
+    }
+  }
+
+  /**
+   * Get user.
+   * @param id user id
+   * @return deleted user
+   */
+  public User getUser(Integer id) {
+    LOGGER.info("get user at: " + id);
+    User user = null;
+    try (var session = factory.openSession()) {
+      var tx = session.beginTransaction();
+      user = session.get(User.class, id);
+      tx.commit();
+    } catch (HibernateException e) {
+      LOGGER.debug("fail to get user", e);
+    }
+    return user;
+  }
+
+  /**
+   * Close hibernate.
+   */
+  public void close() {
+    HibernateUtil.shutdown();
+  }
+}

metadata-mapping/src/main/java/com/iluwatar/metamapping/utils/DatabaseUtil.java

@@ -0,0 +1,39 @@
+package com.iluwatar.metamapping.utils;
+
+import java.sql.SQLException;
+import lombok.extern.slf4j.Slf4j;
+import org.h2.jdbcx.JdbcDataSource;
+
+/**
+ * Create h2 database.
+ */
+@Slf4j
+public class DatabaseUtil {
+  private static final String DB_URL = "jdbc:h2:mem:metamapping";
+  private static final String CREATE_SCHEMA_SQL = "DROP TABLE IF EXISTS `user`;"
+      + "CREATE TABLE `user` (\n"
+      + "  `id` int(11) NOT NULL AUTO_INCREMENT,\n"
+      + "  `username` varchar(255) NOT NULL,\n"
+      + "  `password` varchar(255) NOT NULL,\n"
+      + "  PRIMARY KEY (`id`)\n"
+      + ");";
+
+  /**
+   * Hide constructor.
+   */
+  private DatabaseUtil() {}
+
+  /**
+   * Create database.
+   */
+  static {
+    LOGGER.info("create h2 database");
+    var source = new JdbcDataSource();
+    source.setURL(DB_URL);
+    try (var statement = source.getConnection().createStatement()) {
+      statement.execute(CREATE_SCHEMA_SQL);
+    } catch (SQLException e) {
+      LOGGER.error("unable to create h2 data source", e);
+    }
+  }
+}

metadata-mapping/src/main/java/com/iluwatar/metamapping/utils/HibernateUtil.java

@@ -0,0 +1,45 @@
+package com.iluwatar.metamapping.utils;
+
+import lombok.extern.slf4j.Slf4j;
+import org.hibernate.SessionFactory;
+import org.hibernate.cfg.Configuration;
+
+/**
+ * Manage hibernate.
+ */
+@Slf4j
+public class HibernateUtil {
+
+  private static final SessionFactory sessionFactory = buildSessionFactory();
+
+  /**
+   * Hide constructor.
+   */
+  private HibernateUtil() {}
+
+  /**
+   * Build session factory.
+   * @return session factory
+   */
+  private static SessionFactory buildSessionFactory() {
+    // Create the SessionFactory from hibernate.cfg.xml
+    return new Configuration().configure().buildSessionFactory();
+  }
+
+  /**
+   * Get session factory.
+   * @return session factory
+   */
+  public static SessionFactory getSessionFactory() {
+    return sessionFactory;
+  }
+
+  /**
+   * Close session factory.
+   */
+  public static void shutdown() {
+    // Close caches and connection pools
+    getSessionFactory().close();
+  }
+
+}

metadata-mapping/src/main/resources/com/iluwatar/metamapping/model/User.hbm.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE hibernate-mapping PUBLIC
+    "-//Hibernate/Hibernate Mapping DTD//EN"
+    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
+
+<hibernate-mapping>
+  <class name="com.iluwatar.metamapping.model.User" table="user">
+    <id name="id" type="java.lang.Integer" column="id">
+      <generator class="native"/>
+    </id>
+    <property name="username" column="username" type="java.lang.String"/>
+    <property name="password" column="password" type="java.lang.String"/>
+  </class>
+</hibernate-mapping>

metadata-mapping/src/main/resources/hibernate.cfg.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE hibernate-configuration PUBLIC
+    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
+<hibernate-configuration>
+  <session-factory>
+    <!-- JDBC Database connection settings -->
+    <property name="connection.url">jdbc:h2:mem:metamapping</property>
+    <property name="connection.driver_class">org.h2.Driver</property>
+    <!-- JDBC connection pool settings ... using built-in test pool -->
+    <property name="connection.pool_size">1</property>
+    <!-- Select our SQL dialect -->
+    <property name="dialect">org.hibernate.dialect.H2Dialect</property>
+    <!-- Echo the SQL to stdout -->
+    <property name="show_sql">false</property>
+    <!-- Drop and re-create the database schema on startup -->
+    <property name="hbm2ddl.auto">create-drop</property>
+    <mapping resource="com/iluwatar/metamapping/model/User.hbm.xml" />
+  </session-factory>
+</hibernate-configuration>

metadata-mapping/src/test/java/com/iluwatar/metamapping/AppTest.java

@@ -0,0 +1,20 @@
+package com.iluwatar.metamapping;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+/**
+ * Tests that metadata mapping example runs without errors.
+ */
+class AppTest {
+  /**
+   * Issue: Add at least one assertion to this test case.
+   *
+   * Solution: Inserted assertion to check whether the execution of the main method in {@link App#main(String[])}
+   * throws an exception.
+   */
+  @Test
+  void shouldExecuteMetaMappingWithoutException() {
+    assertDoesNotThrow(() -> App.main(new String[]{}));
+  }
+}

pom.xml

@@ -75,6 +75,7 @@
     <license-maven-plugin.version>3.0</license-maven-plugin.version>
     <urm-maven-plugin.version>1.4.8</urm-maven-plugin.version>
     <commons-io.version>2.7</commons-io.version>
+    <istack-commons-runtime.version>4.0.1</istack-commons-runtime.version>
     <!-- SonarCloud -->
     <sonar.host.url>https://sonarcloud.io</sonar.host.url>
     <sonar.organization>iluwatar</sonar.organization>
@@ -227,6 +228,7 @@
     <module>lockable-object</module>
     <module>fanout-fanin</module>
     <module>domain-model</module>
+    <module>metadata-mapping</module>
   </modules>
   <repositories>
     <repository>
@@ -377,6 +379,11 @@
         <artifactId>commons-io</artifactId>
         <version>${commons-io.version}</version>
       </dependency>
+      <dependency>
+        <groupId>com.sun.istack</groupId>
+        <artifactId>istack-commons-runtime</artifactId>
+        <version>${istack-commons-runtime.version}</version>
+      </dependency>
     </dependencies>
   </dependencyManagement>
   <dependencies>

unit-of-work/README.md

@@ -12,20 +12,20 @@ tags:
 
 ## Intent
 
-When a business transaction is completed, all the the updates are sent as one big unit of work to be 
+When a business transaction is completed, all the updates are sent as one big unit of work to be 
 persisted in one go to minimize database round-trips. 
 
 ## Explanation
 
-Real world example
+Real-world example
 
-> We have a database containing student information. Administrators all over the country are 
-> constantly updating this information and it causes high load on the database server. To make the 
+> Arms dealer has a database containing weapon information. Merchants all over the town are 
+> constantly updating this information and it causes a high load on the database server. To make the 
 > load more manageable we apply to Unit of Work pattern to send many small updates in batches.       
 
 In plain words
 
-> Unit of Work merges many small database updates in single batch to optimize the number of 
+> Unit of Work merges many small database updates in a single batch to optimize the number of 
 > round-trips. 
 
 [MartinFowler.com](https://martinfowler.com/eaaCatalog/unitOfWork.html) says
@@ -35,37 +35,20 @@ In plain words
 
 **Programmatic Example**
 
-Here's the `Student` entity that is being persisted to the database.
+Here's the `Weapon` entity that is being persisted in the database.
 
 ```java
-public class Student {
-  private final Integer id;
-  private final String name;
-  private final String address;
-
-  public Student(Integer id, String name, String address) {
-    this.id = id;
-    this.name = name;
-    this.address = address;
-  }
-
-  public String getName() {
-    return name;
-  }
-
-  public Integer getId() {
-    return id;
-  }
-
-  public String getAddress() {
-    return address;
-  }
+@Getter
+@RequiredArgsConstructor
+public class Weapon {
+    private final Integer id;
+    private final String name;
 }
 ```
 
-The essence of the implementation is the `StudentRepository` implementing the Unit of Work pattern. 
+The essence of the implementation is the `ArmsDealer` implementing the Unit of Work pattern. 
 It maintains a map of database operations (`context`) that need to be done and when `commit` is 
-called it applies them in single batch.
+called it applies them in a single batch.
 
 ```java
 public interface IUnitOfWork<T> {
@@ -84,96 +67,117 @@ public interface IUnitOfWork<T> {
 }
 
 @Slf4j
-public class StudentRepository implements IUnitOfWork<Student> {
+@RequiredArgsConstructor
+public class ArmsDealer implements IUnitOfWork<Weapon> {
 
-  private final Map<String, List<Student>> context;
-  private final StudentDatabase studentDatabase;
+    private final Map<String, List<Weapon>> context;
+    private final WeaponDatabase weaponDatabase;
 
-  public StudentRepository(Map<String, List<Student>> context, StudentDatabase studentDatabase) {
-    this.context = context;
-    this.studentDatabase = studentDatabase;
-  }
-
-  @Override
-  public void registerNew(Student student) {
-    LOGGER.info("Registering {} for insert in context.", student.getName());
-    register(student, IUnitOfWork.INSERT);
-  }
-
-  @Override
-  public void registerModified(Student student) {
-    LOGGER.info("Registering {} for modify in context.", student.getName());
-    register(student, IUnitOfWork.MODIFY);
-
-  }
-
-  @Override
-  public void registerDeleted(Student student) {
-    LOGGER.info("Registering {} for delete in context.", student.getName());
-    register(student, IUnitOfWork.DELETE);
-  }
-
-  private void register(Student student, String operation) {
-    var studentsToOperate = context.get(operation);
-    if (studentsToOperate == null) {
-      studentsToOperate = new ArrayList<>();
-    }
-    studentsToOperate.add(student);
-    context.put(operation, studentsToOperate);
-  }
-
-  @Override
-  public void commit() {
-    if (context == null || context.size() == 0) {
-      return;
-    }
-    LOGGER.info("Commit started");
-    if (context.containsKey(IUnitOfWork.INSERT)) {
-      commitInsert();
+    @Override
+    public void registerNew(Weapon weapon) {
+        LOGGER.info("Registering {} for insert in context.", weapon.getName());
+        register(weapon, UnitActions.INSERT.getActionValue());
     }
 
-    if (context.containsKey(IUnitOfWork.MODIFY)) {
-      commitModify();
-    }
-    if (context.containsKey(IUnitOfWork.DELETE)) {
-      commitDelete();
-    }
-    LOGGER.info("Commit finished.");
-  }
+    @Override
+    public void registerModified(Weapon weapon) {
+        LOGGER.info("Registering {} for modify in context.", weapon.getName());
+        register(weapon, UnitActions.MODIFY.getActionValue());
 
-  private void commitInsert() {
-    var studentsToBeInserted = context.get(IUnitOfWork.INSERT);
-    for (var student : studentsToBeInserted) {
-      LOGGER.info("Saving {} to database.", student.getName());
-      studentDatabase.insert(student);
     }
-  }
 
-  private void commitModify() {
-    var modifiedStudents = context.get(IUnitOfWork.MODIFY);
-    for (var student : modifiedStudents) {
-      LOGGER.info("Modifying {} to database.", student.getName());
-      studentDatabase.modify(student);
+    @Override
+    public void registerDeleted(Weapon weapon) {
+        LOGGER.info("Registering {} for delete in context.", weapon.getName());
+        register(weapon, UnitActions.DELETE.getActionValue());
     }
-  }
 
-  private void commitDelete() {
-    var deletedStudents = context.get(IUnitOfWork.DELETE);
-    for (var student : deletedStudents) {
-      LOGGER.info("Deleting {} to database.", student.getName());
-      studentDatabase.delete(student);
+    private void register(Weapon weapon, String operation) {
+        var weaponsToOperate = context.get(operation);
+        if (weaponsToOperate == null) {
+            weaponsToOperate = new ArrayList<>();
+        }
+        weaponsToOperate.add(weapon);
+        context.put(operation, weaponsToOperate);
+    }
+
+    /**
+     * All UnitOfWork operations are batched and executed together on commit only.
+     */
+    @Override
+    public void commit() {
+        if (context == null || context.size() == 0) {
+            return;
+        }
+        LOGGER.info("Commit started");
+        if (context.containsKey(UnitActions.INSERT.getActionValue())) {
+            commitInsert();
+        }
+
+        if (context.containsKey(UnitActions.MODIFY.getActionValue())) {
+            commitModify();
+        }
+        if (context.containsKey(UnitActions.DELETE.getActionValue())) {
+            commitDelete();
+        }
+        LOGGER.info("Commit finished.");
+    }
+
+    private void commitInsert() {
+        var weaponsToBeInserted = context.get(UnitActions.INSERT.getActionValue());
+        for (var weapon : weaponsToBeInserted) {
+            LOGGER.info("Inserting a new weapon {} to sales rack.", weapon.getName());
+            weaponDatabase.insert(weapon);
+        }
+    }
+
+    private void commitModify() {
+        var modifiedWeapons = context.get(UnitActions.MODIFY.getActionValue());
+        for (var weapon : modifiedWeapons) {
+            LOGGER.info("Scheduling {} for modification work.", weapon.getName());
+            weaponDatabase.modify(weapon);
+        }
+    }
+
+    private void commitDelete() {
+        var deletedWeapons = context.get(UnitActions.DELETE.getActionValue());
+        for (var weapon : deletedWeapons) {
+            LOGGER.info("Scrapping {}.", weapon.getName());
+            weaponDatabase.delete(weapon);
+        }
     }
-  }
 }
 ```
 
-Finally, here's how we use the `StudentRepository` and `commit` the transaction.
+Here is how the whole app is put together.
 
 ```java
-    studentRepository.registerNew(ram);
-    studentRepository.registerModified(shyam);
-    studentRepository.registerDeleted(gopi);
-    studentRepository.commit();
+// create some weapons
+var enchantedHammer = new Weapon(1, "enchanted hammer");
+var brokenGreatSword = new Weapon(2, "broken great sword");
+var silverTrident = new Weapon(3, "silver trident");
+
+// create repository
+var weaponRepository = new ArmsDealer(new HashMap<String, List<Weapon>>(), new WeaponDatabase());
+
+// perform operations on the weapons
+weaponRepository.registerNew(enchantedHammer);
+weaponRepository.registerModified(silverTrident);
+weaponRepository.registerDeleted(brokenGreatSword);
+weaponRepository.commit();
+```
+
+Here is the console output.
+
+```
+21:39:21.984 [main] INFO com.iluwatar.unitofwork.ArmsDealer - Registering enchanted hammer for insert in context.
+21:39:21.989 [main] INFO com.iluwatar.unitofwork.ArmsDealer - Registering silver trident for modify in context.
+21:39:21.989 [main] INFO com.iluwatar.unitofwork.ArmsDealer - Registering broken great sword for delete in context.
+21:39:21.989 [main] INFO com.iluwatar.unitofwork.ArmsDealer - Commit started
+21:39:21.989 [main] INFO com.iluwatar.unitofwork.ArmsDealer - Inserting a new weapon enchanted hammer to sales rack.
+21:39:21.989 [main] INFO com.iluwatar.unitofwork.ArmsDealer - Scheduling silver trident for modification work.
+21:39:21.989 [main] INFO com.iluwatar.unitofwork.ArmsDealer - Scrapping broken great sword.
+21:39:21.989 [main] INFO com.iluwatar.unitofwork.ArmsDealer - Commit finished.
 ```
 
 ## Class diagram
@@ -186,7 +190,7 @@ Use the Unit Of Work pattern when
 
 * To optimize the time taken for database transactions.
 * To send changes to database as a unit of work which ensures atomicity of the transaction.
-* To reduce number of database calls.
+* To reduce the number of database calls.
 
 ## Tutorials
 

unit-of-work/etc/unit-of-work.ucls

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <class-diagram version="1.2.1" icons="true" always-add-relationships="false" generalizations="true" realizations="true" 
   associations="true" dependencies="false" nesting-relationships="true" router="FAN">  
-  <class id="1" language="java" name="com.iluwatar.unitofwork.StudentDatabase" project="unit-of-work" 
+  <class id="1" language="java" name="com.iluwatar.unitofwork.WeaponDatabase" project="unit-of-work"
     file="/unit-of-work/src/main/java/com/iluwatar/unitofwork/StudentDatabase.java" binary="false" corner="BOTTOM_RIGHT">    
     <position height="-1" width="-1" x="170" y="406"/>    
     <display autosize="true" stereotype="true" package="true" initial-value="false" signature="true" 
@@ -28,7 +28,7 @@
       <operations public="true" package="true" protected="true" private="true" static="true"/>    
     </display>  
   </class>  
-  <class id="4" language="java" name="com.iluwatar.unitofwork.StudentRepository" project="unit-of-work" 
+  <class id="4" language="java" name="com.iluwatar.unitofwork.ArmsDealer" project="unit-of-work"
     file="/unit-of-work/src/main/java/com/iluwatar/unitofwork/StudentRepository.java" binary="false" 
     corner="BOTTOM_RIGHT">    
     <position height="-1" width="-1" x="377" y="166"/>    
@@ -38,7 +38,7 @@
       <operations public="true" package="true" protected="true" private="true" static="true"/>    
     </display>  
   </class>  
-  <class id="5" language="java" name="com.iluwatar.unitofwork.Student" project="unit-of-work" 
+  <class id="5" language="java" name="com.iluwatar.unitofwork.Weapon" project="unit-of-work"
     file="/unit-of-work/src/main/java/com/iluwatar/unitofwork/Student.java" binary="false" corner="BOTTOM_RIGHT">    
     <position height="-1" width="-1" x="696" y="130"/>    
     <display autosize="true" stereotype="true" package="true" initial-value="false" signature="true" 

unit-of-work/src/main/java/com/iluwatar/unitofwork/App.java

@@ -27,7 +27,7 @@ import java.util.HashMap;
 import java.util.List;
 
 /**
- * {@link App} Application for managing student data.
+ * {@link App} Application demonstrating unit of work pattern.
  */
 public class App {
   /**
@@ -37,17 +37,19 @@ public class App {
    */
 
   public static void main(String[] args) {
-    var ram = new Student(1, "Ram", "Street 9, Cupertino");
-    var shyam = new Student(2, "Shyam", "Z bridge, Pune");
-    var gopi = new Student(3, "Gopi", "Street 10, Mumbai");
+    // create some weapons
+    var enchantedHammer = new Weapon(1, "enchanted hammer");
+    var brokenGreatSword = new Weapon(2, "broken great sword");
+    var silverTrident = new Weapon(3, "silver trident");
 
-    var context = new HashMap<String, List<Student>>();
-    var studentDatabase = new StudentDatabase();
-    var studentRepository = new StudentRepository(context, studentDatabase);
+    // create repository
+    var weaponRepository = new ArmsDealer(new HashMap<String, List<Weapon>>(),
+            new WeaponDatabase());
 
-    studentRepository.registerNew(ram);
-    studentRepository.registerModified(shyam);
-    studentRepository.registerDeleted(gopi);
-    studentRepository.commit();
+    // perform operations on the weapons
+    weaponRepository.registerNew(enchantedHammer);
+    weaponRepository.registerModified(silverTrident);
+    weaponRepository.registerDeleted(brokenGreatSword);
+    weaponRepository.commit();
   }
 }

unit-of-work/src/main/java/com/iluwatar/unitofwork/ArmsDealer.java

@@ -30,41 +30,41 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
 /**
- * {@link StudentRepository} Student database repository. supports unit of work for student data.
+ * {@link ArmsDealer} Weapon repository that supports unit of work for weapons.
  */
 @Slf4j
 @RequiredArgsConstructor
-public class StudentRepository implements IUnitOfWork<Student> {
+public class ArmsDealer implements IUnitOfWork<Weapon> {
 
-  private final Map<String, List<Student>> context;
-  private final StudentDatabase studentDatabase;
+  private final Map<String, List<Weapon>> context;
+  private final WeaponDatabase weaponDatabase;
 
   @Override
-  public void registerNew(Student student) {
-    LOGGER.info("Registering {} for insert in context.", student.getName());
-    register(student, UnitActions.INSERT.getActionValue());
+  public void registerNew(Weapon weapon) {
+    LOGGER.info("Registering {} for insert in context.", weapon.getName());
+    register(weapon, UnitActions.INSERT.getActionValue());
   }
 
   @Override
-  public void registerModified(Student student) {
-    LOGGER.info("Registering {} for modify in context.", student.getName());
-    register(student, UnitActions.MODIFY.getActionValue());
+  public void registerModified(Weapon weapon) {
+    LOGGER.info("Registering {} for modify in context.", weapon.getName());
+    register(weapon, UnitActions.MODIFY.getActionValue());
 
   }
 
   @Override
-  public void registerDeleted(Student student) {
-    LOGGER.info("Registering {} for delete in context.", student.getName());
-    register(student, UnitActions.DELETE.getActionValue());
+  public void registerDeleted(Weapon weapon) {
+    LOGGER.info("Registering {} for delete in context.", weapon.getName());
+    register(weapon, UnitActions.DELETE.getActionValue());
   }
 
-  private void register(Student student, String operation) {
-    var studentsToOperate = context.get(operation);
-    if (studentsToOperate == null) {
-      studentsToOperate = new ArrayList<>();
+  private void register(Weapon weapon, String operation) {
+    var weaponsToOperate = context.get(operation);
+    if (weaponsToOperate == null) {
+      weaponsToOperate = new ArrayList<>();
     }
-    studentsToOperate.add(student);
-    context.put(operation, studentsToOperate);
+    weaponsToOperate.add(weapon);
+    context.put(operation, weaponsToOperate);
   }
 
   /**
@@ -90,26 +90,26 @@ public class StudentRepository implements IUnitOfWork<Student> {
   }
 
   private void commitInsert() {
-    var studentsToBeInserted = context.get(UnitActions.INSERT.getActionValue());
-    for (var student : studentsToBeInserted) {
-      LOGGER.info("Saving {} to database.", student.getName());
-      studentDatabase.insert(student);
+    var weaponsToBeInserted = context.get(UnitActions.INSERT.getActionValue());
+    for (var weapon : weaponsToBeInserted) {
+      LOGGER.info("Inserting a new weapon {} to sales rack.", weapon.getName());
+      weaponDatabase.insert(weapon);
     }
   }
 
   private void commitModify() {
-    var modifiedStudents = context.get(UnitActions.MODIFY.getActionValue());
-    for (var student : modifiedStudents) {
-      LOGGER.info("Modifying {} to database.", student.getName());
-      studentDatabase.modify(student);
+    var modifiedWeapons = context.get(UnitActions.MODIFY.getActionValue());
+    for (var weapon : modifiedWeapons) {
+      LOGGER.info("Scheduling {} for modification work.", weapon.getName());
+      weaponDatabase.modify(weapon);
     }
   }
 
   private void commitDelete() {
-    var deletedStudents = context.get(UnitActions.DELETE.getActionValue());
-    for (var student : deletedStudents) {
-      LOGGER.info("Deleting {} to database.", student.getName());
-      studentDatabase.delete(student);
+    var deletedWeapons = context.get(UnitActions.DELETE.getActionValue());
+    for (var weapon : deletedWeapons) {
+      LOGGER.info("Scrapping {}.", weapon.getName());
+      weaponDatabase.delete(weapon);
     }
   }
 }

unit-of-work/src/main/java/com/iluwatar/unitofwork/Weapon.java

@@ -27,14 +27,12 @@ import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 
 /**
- * {@link Student} is an entity.
+ * {@link Weapon} is an entity.
  */
 @Getter
 @RequiredArgsConstructor
-public class Student {
+public class Weapon {
 
   private final Integer id;
   private final String name;
-  private final String address;
-
 }

unit-of-work/src/main/java/com/iluwatar/unitofwork/WeaponDatabase.java

@@ -24,19 +24,19 @@
 package com.iluwatar.unitofwork;
 
 /**
- * Act as Database for student records.
+ * Act as database for weapon records.
  */
-public class StudentDatabase {
+public class WeaponDatabase {
 
-  public void insert(Student student) {
+  public void insert(Weapon weapon) {
     //Some insert logic to DB
   }
 
-  public void modify(Student student) {
+  public void modify(Weapon weapon) {
     //Some modify logic to DB
   }
 
-  public void delete(Student student) {
+  public void delete(Weapon weapon) {
     //Some delete logic to DB
   }
 }

unit-of-work/src/test/java/com/iluwatar/unitofwork/ArmsDealerTest.java

@@ -36,102 +36,102 @@ import java.util.Map;
 import org.junit.jupiter.api.Test;
 
 /**
- * tests {@link StudentRepository}
+ * tests {@link ArmsDealer}
  */
 
-class StudentRepositoryTest {
-  private final Student student1 = new Student(1, "Ram", "street 9, cupertino");
-  private final Student student2 = new Student(1, "Sham", "Z bridge, pune");
+class ArmsDealerTest {
+  private final Weapon weapon1 = new Weapon(1, "battle ram");
+  private final Weapon weapon2 = new Weapon(1, "wooden lance");
 
-  private final Map<String, List<Student>> context = new HashMap<>();
-  private final StudentDatabase studentDatabase = mock(StudentDatabase.class);
-  private final StudentRepository studentRepository = new StudentRepository(context, studentDatabase);;
+  private final Map<String, List<Weapon>> context = new HashMap<>();
+  private final WeaponDatabase weaponDatabase = mock(WeaponDatabase.class);
+  private final ArmsDealer armsDealer = new ArmsDealer(context, weaponDatabase);;
 
   @Test
   void shouldSaveNewStudentWithoutWritingToDb() {
-    studentRepository.registerNew(student1);
-    studentRepository.registerNew(student2);
+    armsDealer.registerNew(weapon1);
+    armsDealer.registerNew(weapon2);
 
     assertEquals(2, context.get(UnitActions.INSERT.getActionValue()).size());
-    verifyNoMoreInteractions(studentDatabase);
+    verifyNoMoreInteractions(weaponDatabase);
   }
 
   @Test
   void shouldSaveDeletedStudentWithoutWritingToDb() {
-    studentRepository.registerDeleted(student1);
-    studentRepository.registerDeleted(student2);
+    armsDealer.registerDeleted(weapon1);
+    armsDealer.registerDeleted(weapon2);
 
     assertEquals(2, context.get(UnitActions.DELETE.getActionValue()).size());
-    verifyNoMoreInteractions(studentDatabase);
+    verifyNoMoreInteractions(weaponDatabase);
   }
 
   @Test
   void shouldSaveModifiedStudentWithoutWritingToDb() {
-    studentRepository.registerModified(student1);
-    studentRepository.registerModified(student2);
+    armsDealer.registerModified(weapon1);
+    armsDealer.registerModified(weapon2);
 
     assertEquals(2, context.get(UnitActions.MODIFY.getActionValue()).size());
-    verifyNoMoreInteractions(studentDatabase);
+    verifyNoMoreInteractions(weaponDatabase);
   }
 
   @Test
   void shouldSaveAllLocalChangesToDb() {
-    context.put(UnitActions.INSERT.getActionValue(), List.of(student1));
-    context.put(UnitActions.MODIFY.getActionValue(), List.of(student1));
-    context.put(UnitActions.DELETE.getActionValue(), List.of(student1));
+    context.put(UnitActions.INSERT.getActionValue(), List.of(weapon1));
+    context.put(UnitActions.MODIFY.getActionValue(), List.of(weapon1));
+    context.put(UnitActions.DELETE.getActionValue(), List.of(weapon1));
 
-    studentRepository.commit();
+    armsDealer.commit();
 
-    verify(studentDatabase, times(1)).insert(student1);
-    verify(studentDatabase, times(1)).modify(student1);
-    verify(studentDatabase, times(1)).delete(student1);
+    verify(weaponDatabase, times(1)).insert(weapon1);
+    verify(weaponDatabase, times(1)).modify(weapon1);
+    verify(weaponDatabase, times(1)).delete(weapon1);
   }
 
   @Test
   void shouldNotWriteToDbIfContextIsNull() {
-    var studentRepository = new StudentRepository(null, studentDatabase);
+    var weaponRepository = new ArmsDealer(null, weaponDatabase);
 
-    studentRepository.commit();
+    weaponRepository.commit();
 
-    verifyNoMoreInteractions(studentDatabase);
+    verifyNoMoreInteractions(weaponDatabase);
   }
 
   @Test
   void shouldNotWriteToDbIfNothingToCommit() {
-    var studentRepository = new StudentRepository(new HashMap<>(), studentDatabase);
+    var weaponRepository = new ArmsDealer(new HashMap<>(), weaponDatabase);
 
-    studentRepository.commit();
+    weaponRepository.commit();
 
-    verifyNoMoreInteractions(studentDatabase);
+    verifyNoMoreInteractions(weaponDatabase);
   }
 
   @Test
   void shouldNotInsertToDbIfNoRegisteredStudentsToBeCommitted() {
-    context.put(UnitActions.MODIFY.getActionValue(), List.of(student1));
-    context.put(UnitActions.DELETE.getActionValue(), List.of(student1));
+    context.put(UnitActions.MODIFY.getActionValue(), List.of(weapon1));
+    context.put(UnitActions.DELETE.getActionValue(), List.of(weapon1));
 
-    studentRepository.commit();
+    armsDealer.commit();
 
-    verify(studentDatabase, never()).insert(student1);
+    verify(weaponDatabase, never()).insert(weapon1);
   }
 
   @Test
   void shouldNotModifyToDbIfNotRegisteredStudentsToBeCommitted() {
-    context.put(UnitActions.INSERT.getActionValue(), List.of(student1));
-    context.put(UnitActions.DELETE.getActionValue(), List.of(student1));
+    context.put(UnitActions.INSERT.getActionValue(), List.of(weapon1));
+    context.put(UnitActions.DELETE.getActionValue(), List.of(weapon1));
 
-    studentRepository.commit();
+    armsDealer.commit();
 
-    verify(studentDatabase, never()).modify(student1);
+    verify(weaponDatabase, never()).modify(weapon1);
   }
 
   @Test
   void shouldNotDeleteFromDbIfNotRegisteredStudentsToBeCommitted() {
-    context.put(UnitActions.INSERT.getActionValue(), List.of(student1));
-    context.put(UnitActions.MODIFY.getActionValue(), List.of(student1));
+    context.put(UnitActions.INSERT.getActionValue(), List.of(weapon1));
+    context.put(UnitActions.MODIFY.getActionValue(), List.of(weapon1));
 
-    studentRepository.commit();
+    armsDealer.commit();
 
-    verify(studentDatabase, never()).delete(student1);
+    verify(weaponDatabase, never()).delete(weapon1);
   }
 }