New unit test format

persistence-modules/hibernate-mapping/README.md

@@ -0,0 +1,7 @@
+
+### Relevant Articles: 
+
+- [Persisting Maps with Hibernate](https://www.baeldung.com/hibernate-persisting-maps)
+- [Difference Between @Size, @Length, and @Column(length=value)](https://www.baeldung.com/jpa-size-length-column-differences)
+- [Hibernate Validator Specific Constraints](https://www.baeldung.com/hibernate-validator-constraints)
+- [Hibernate One to Many Annotation Tutorial](http://www.baeldung.com/hibernate-one-to-many)

persistence-modules/hibernate-mapping/pom.xml

@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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">
+    <artifactId>hibernate-mapping</artifactId>
+    <version>1.0.0-SNAPSHOT</version>
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>persistence-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>..</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-core</artifactId>
+            <version>${hibernate.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <version>${h2.version}</version>
+        </dependency>
+        <!-- validation -->
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-validator</artifactId>
+            <version>${hibernate-validator.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish</groupId>
+            <artifactId>javax.el</artifactId>
+            <version>${org.glassfish.javax.el.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.money</groupId>
+            <artifactId>money-api</artifactId>
+            <version>${money-api.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.javamoney</groupId>
+            <artifactId>moneta</artifactId>
+            <version>${moneta.version}</version>
+            <type>pom</type>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>hibernate-mapping</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+    </build>
+
+    <properties>
+        <hibernate.version>5.3.10.Final</hibernate.version>
+        <assertj-core.version>3.8.0</assertj-core.version>
+        <hibernate-validator.version>6.0.16.Final</hibernate-validator.version>
+        <org.glassfish.javax.el.version>3.0.1-b11</org.glassfish.javax.el.version>
+        <money-api.version>1.0.3</money-api.version>
+        <moneta.version>1.3</moneta.version>
+    </properties>
+
+</project>

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/HibernateUtil.java

@@ -0,0 +1,60 @@
+package com.baeldung.hibernate;
+
+import org.hibernate.SessionFactory;
+import org.hibernate.boot.Metadata;
+import org.hibernate.boot.MetadataSources;
+import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
+import org.hibernate.service.ServiceRegistry;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.util.Properties;
+
+public class HibernateUtil {
+
+    private HibernateUtil() {
+    }
+
+    public static SessionFactory getSessionFactory(Strategy strategy) {
+        return buildSessionFactory(strategy);
+    }
+
+    private static SessionFactory buildSessionFactory(Strategy strategy) {
+        try {
+            ServiceRegistry serviceRegistry = configureServiceRegistry();
+
+            MetadataSources metadataSources = new MetadataSources(serviceRegistry);
+
+            for (Class<?> entityClass : strategy.getEntityClasses()) {
+                metadataSources.addAnnotatedClass(entityClass);
+            }
+
+            Metadata metadata = metadataSources.getMetadataBuilder()
+                    .build();
+
+            return metadata.getSessionFactoryBuilder()
+                    .build();
+        } catch (IOException ex) {
+            throw new ExceptionInInitializerError(ex);
+        }
+    }
+
+
+    private static ServiceRegistry configureServiceRegistry() throws IOException {
+        Properties properties = getProperties();
+        return new StandardServiceRegistryBuilder().applySettings(properties)
+                .build();
+    }
+
+    private static Properties getProperties() throws IOException {
+        Properties properties = new Properties();
+        URL propertiesURL = Thread.currentThread()
+                .getContextClassLoader()
+                .getResource("hibernate.properties");
+        try (FileInputStream inputStream = new FileInputStream(propertiesURL.getFile())) {
+            properties.load(inputStream);
+        }
+        return properties;
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/Strategy.java

@@ -0,0 +1,31 @@
+package com.baeldung.hibernate;
+
+
+import java.util.Arrays;
+import java.util.List;
+
+public enum Strategy {
+    //See that the classes belongs to different packages
+    MAP_KEY_COLUMN_BASED(Arrays.asList(com.baeldung.hibernate.persistmaps.mapkeycolumn.Order.class, 
+            com.baeldung.hibernate.basicannotation.Course.class)),
+    MAP_KEY_BASED(Arrays.asList(com.baeldung.hibernate.persistmaps.mapkey.Item.class,
+            com.baeldung.hibernate.persistmaps.mapkey.Order.class,com.baeldung.hibernate.persistmaps.mapkey.User.class)),
+    MAP_KEY_JOIN_COLUMN_BASED(Arrays.asList(com.baeldung.hibernate.persistmaps.mapkeyjoincolumn.Seller.class,
+            com.baeldung.hibernate.persistmaps.mapkeyjoincolumn.Item.class,
+            com.baeldung.hibernate.persistmaps.mapkeyjoincolumn.Order.class)),
+    MAP_KEY_ENUMERATED_BASED(Arrays.asList(com.baeldung.hibernate.persistmaps.mapkeyenumerated.Order.class,
+            com.baeldung.hibernate.persistmaps.mapkey.Item.class)),
+    MAP_KEY_TEMPORAL_BASED(Arrays.asList(com.baeldung.hibernate.persistmaps.mapkeytemporal.Order.class,
+            com.baeldung.hibernate.persistmaps.mapkey.Item.class));
+
+
+    private List<Class<?>> entityClasses;
+
+    Strategy(List<Class<?>> entityClasses) {
+        this.entityClasses = entityClasses;
+    }
+
+    public List<Class<?>> getEntityClasses() {
+        return entityClasses;
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/basicannotation/Course.java

@@ -0,0 +1,34 @@
+package com.baeldung.hibernate.basicannotation;
+
+import javax.persistence.Basic;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+
+@Entity
+public class Course {
+
+    @Id
+    private int id;
+
+    @Basic(optional = false, fetch = FetchType.LAZY)
+    private String name;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}
+

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/oneToMany/config/HibernateAnnotationUtil.java

@@ -0,0 +1,34 @@
+package com.baeldung.hibernate.oneToMany.config;
+
+import org.hibernate.SessionFactory;
+import org.hibernate.boot.Metadata;
+import org.hibernate.boot.MetadataSources;
+import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
+import org.hibernate.service.ServiceRegistry;
+
+public class HibernateAnnotationUtil {
+
+    private static SessionFactory sessionFactory;
+
+    private static SessionFactory buildSessionFactory() {
+        try {
+            // Create the SessionFactory from hibernate-annotation.cfg.xml
+            ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().configure("hibernate-annotation.cfg.xml").build();
+            Metadata metadata = new MetadataSources(serviceRegistry).getMetadataBuilder().build();
+            SessionFactory sessionFactory = metadata.getSessionFactoryBuilder().build();
+
+            return sessionFactory;
+
+        } catch (Throwable ex) {
+            System.err.println("Initial SessionFactory creation failed." + ex);
+            ex.printStackTrace();
+            throw new ExceptionInInitializerError(ex);
+        }
+    }
+
+    public static SessionFactory getSessionFactory() {
+        if (sessionFactory == null)
+            sessionFactory = buildSessionFactory();
+        return sessionFactory;
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/oneToMany/main/HibernateManyisOwningSide.java

@@ -0,0 +1,71 @@
+package com.baeldung.hibernate.oneToMany.main;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.Transaction;
+
+import com.baeldung.hibernate.oneToMany.config.HibernateAnnotationUtil;
+import com.baeldung.hibernate.oneToMany.model.Cart;
+import com.baeldung.hibernate.oneToMany.model.Items;
+import com.baeldung.hibernate.oneToMany.model.ItemsOIO;
+
+public class HibernateManyisOwningSide {
+    public static void main(String[] args) {
+
+        Cart cart = new Cart();
+        Cart cart2 = new Cart();
+
+        Items item1 = new Items(cart);
+        Items item2 = new Items(cart2);
+        Set<Items> itemsSet = new HashSet<Items>();
+        itemsSet.add(item1);
+        itemsSet.add(item2);
+
+        cart.setItems(itemsSet);
+
+        
+        
+        SessionFactory sessionFactory = null;
+        Session session = null;
+        Transaction tx = null;
+        try {
+            // Get Session
+            sessionFactory = HibernateAnnotationUtil.getSessionFactory();
+            session = sessionFactory.getCurrentSession();
+            System.out.println("Session created");
+            // start transaction
+            tx = session.beginTransaction();
+            // Save the Model object
+            session.save(cart);
+            session.save(cart2);
+            session.save(item1);
+            session.save(item2);
+            // Commit transaction
+            tx.commit();
+            session = sessionFactory.getCurrentSession();
+            tx = session.beginTransaction();
+
+            item1 = (Items) session.get(Items.class, new Long(1));
+            item2 = (Items) session.get(Items.class, new Long(2));
+            tx.commit();
+            
+         
+            System.out.println("item1 ID=" + item1.getId() + ", Foreign Key CartOIO ID=" + item1.getCart()
+                .getId());
+            System.out.println("item2 ID=" + item2.getId() + ", Foreign Key CartOIO ID=" + item2.getCart()
+                .getId());
+
+        } catch (Exception e) {
+            System.out.println("Exception occured. " + e.getMessage());
+            e.printStackTrace();
+        } finally {
+            if (!sessionFactory.isClosed()) {
+                System.out.println("Closing SessionFactory");
+                sessionFactory.close();
+            }
+        }
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/oneToMany/main/HibernateOneToManyAnnotationMain.java

@@ -0,0 +1,60 @@
+package com.baeldung.hibernate.oneToMany.main;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.Transaction;
+
+import com.baeldung.hibernate.oneToMany.config.HibernateAnnotationUtil;
+import com.baeldung.hibernate.oneToMany.model.Cart;
+import com.baeldung.hibernate.oneToMany.model.Items;
+
+public class HibernateOneToManyAnnotationMain {
+
+    public static void main(String[] args) {
+
+        Cart cart = new Cart();
+
+        Items item1 = new Items(cart);
+        Items item2 = new Items(cart);
+        Set<Items> itemsSet = new HashSet<Items>();
+        itemsSet.add(item1);
+        itemsSet.add(item2);
+
+        cart.setItems(itemsSet);
+        
+
+        SessionFactory sessionFactory = null;
+        Session session = null;
+        Transaction tx = null;
+        try {
+            // Get Session
+            sessionFactory = HibernateAnnotationUtil.getSessionFactory();
+            session = sessionFactory.getCurrentSession();
+            System.out.println("Session created");
+            // start transaction
+            tx = session.beginTransaction();
+            // Save the Model object
+            session.save(cart);
+            session.save(item1);
+            session.save(item2);
+            // Commit transaction
+            tx.commit();
+            System.out.println("Cart ID=" + cart.getId());
+            System.out.println("item1 ID=" + item1.getId() + ", Foreign Key Cart ID=" + item1.getCart().getId());
+            System.out.println("item2 ID=" + item2.getId() + ", Foreign Key Cart ID=" + item1.getCart().getId());
+
+        } catch (Exception e) {
+            System.out.println("Exception occured. " + e.getMessage());
+            e.printStackTrace();
+        } finally {
+            if (!sessionFactory.isClosed()) {
+                System.out.println("Closing SessionFactory");
+                sessionFactory.close();
+            }
+        }
+    }
+
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/oneToMany/main/HibernateOneisOwningSide.java

@@ -0,0 +1,67 @@
+package com.baeldung.hibernate.oneToMany.main;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.Transaction;
+
+import com.baeldung.hibernate.oneToMany.config.HibernateAnnotationUtil;
+import com.baeldung.hibernate.oneToMany.model.CartOIO;
+import com.baeldung.hibernate.oneToMany.model.ItemsOIO;
+
+public class HibernateOneisOwningSide {
+    public static void main(String[] args) {
+
+        CartOIO cart = new CartOIO();
+        CartOIO cart2 = new CartOIO();
+
+        ItemsOIO item1 = new ItemsOIO(cart);
+        ItemsOIO item2 = new ItemsOIO(cart2);
+        Set<ItemsOIO> itemsSet = new HashSet<ItemsOIO>();
+        itemsSet.add(item1);
+        itemsSet.add(item2);
+
+        cart.setItems(itemsSet);
+
+        SessionFactory sessionFactory = null;
+        Session session = null;
+        Transaction tx = null;
+        try {
+            // Get Session
+            sessionFactory = HibernateAnnotationUtil.getSessionFactory();
+            session = sessionFactory.getCurrentSession();
+            System.out.println("Session created");
+            // start transaction
+            tx = session.beginTransaction();
+            // Save the Model object
+            session.save(cart);
+            session.save(cart2);
+            session.save(item1);
+            session.save(item2);
+            // Commit transaction
+            tx.commit();
+
+            session = sessionFactory.getCurrentSession();
+            tx = session.beginTransaction();
+            item1 = (ItemsOIO) session.get(ItemsOIO.class, new Long(1));
+            item2 = (ItemsOIO) session.get(ItemsOIO.class, new Long(2));
+            tx.commit();
+
+            System.out.println("item1 ID=" + item1.getId() + ", Foreign Key CartOIO ID=" + item1.getCartOIO()
+                .getId());
+            System.out.println("item2 ID=" + item2.getId() + ", Foreign Key CartOIO ID=" + item2.getCartOIO()
+                .getId());
+
+        } catch (Exception e) {
+            System.out.println("Exception occured. " + e.getMessage());
+            e.printStackTrace();
+        } finally {
+            if (!sessionFactory.isClosed()) {
+                System.out.println("Closing SessionFactory");
+                sessionFactory.close();
+            }
+        }
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/oneToMany/model/Cart.java

@@ -0,0 +1,43 @@
+package com.baeldung.hibernate.oneToMany.model;
+
+import java.util.Set;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.OneToMany;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "CART")
+public class Cart {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "cart_id")
+    private long id;
+
+
+    @OneToMany(mappedBy = "cart")
+    private Set<Items> items;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+
+    public Set<Items> getItems() {
+        return items;
+    }
+
+    public void setItems(Set<Items> items) {
+        this.items = items;
+    }
+
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/oneToMany/model/CartOIO.java

@@ -0,0 +1,42 @@
+package com.baeldung.hibernate.oneToMany.model;
+
+import java.util.Set;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.OneToMany;
+import javax.persistence.Table;
+
+
+
+@Entity
+@Table(name = "CARTOIO")
+public class CartOIO {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private long id;
+
+    @OneToMany
+    @JoinColumn(name = "cart_id") // we need to duplicate the physical information
+    private Set<ItemsOIO> items;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Set<ItemsOIO> getItems() {
+        return items;
+    }
+
+    public void setItems(Set<ItemsOIO> items) {
+        this.items = items;
+    }
+
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/oneToMany/model/Items.java

@@ -0,0 +1,50 @@
+package com.baeldung.hibernate.oneToMany.model;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "ITEMS")
+public class Items {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private long id;
+
+
+    @ManyToOne
+    @JoinColumn(name = "cart_id", nullable = false)
+    private Cart cart;
+
+    // Hibernate requires no-args constructor
+    public Items() {
+    }
+
+    public Items(Cart c) {
+        this.cart = c;
+    }
+
+    public Cart getCart() {
+        return cart;
+    }
+
+    public void setCart(Cart cart) {
+        this.cart = cart;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/oneToMany/model/ItemsOIO.java

@@ -0,0 +1,47 @@
+package com.baeldung.hibernate.oneToMany.model;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "ITEMSOIO")
+public class ItemsOIO {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private long id;
+
+    @ManyToOne
+    @JoinColumn(name = "cart_id", insertable = false, updatable = false)
+    private CartOIO cart;
+
+    // Hibernate requires no-args constructor
+    public ItemsOIO() {
+    }
+
+    public ItemsOIO(CartOIO c) {
+        this.cart = c;
+    }
+
+    public CartOIO getCartOIO() {
+        return cart;
+    }
+
+    public void setCartOIO(CartOIO cart) {
+        this.cart = cart;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/persistmaps/ItemType.java

@@ -0,0 +1,6 @@
+package com.baeldung.hibernate.persistmaps;
+
+public enum ItemType {
+    JEANS,
+    TSHIRTS
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/persistmaps/mapkey/Item.java

@@ -0,0 +1,95 @@
+package com.baeldung.hibernate.persistmaps.mapkey;
+
+import com.baeldung.hibernate.persistmaps.ItemType;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+import java.util.Date;
+import java.util.Objects;
+
+@Entity
+@Table(name = "item")
+public class Item {
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+    @Column(name = "name")
+    private String itemName;
+
+    @Column(name = "price")
+    private double itemPrice;
+
+    @Enumerated(EnumType.STRING)
+    @Column(name = "item_type")
+    private ItemType itemType;
+
+    @Temporal(TemporalType.TIMESTAMP)
+    @Column(name = "created_on")
+    private Date createdOn;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getItemName() {
+        return itemName;
+    }
+
+    public void setItemName(String itemName) {
+        this.itemName = itemName;
+    }
+
+    public double getItemPrice() {
+        return itemPrice;
+    }
+
+    public void setItemPrice(double itemPrice) {
+        this.itemPrice = itemPrice;
+    }
+
+    public ItemType getItemType() {
+        return itemType;
+    }
+
+    public void setItemType(ItemType itemType) {
+        this.itemType = itemType;
+    }
+
+    public Date getCreatedOn() {
+        return createdOn;
+    }
+
+    public void setCreatedOn(Date createdOn) {
+        this.createdOn = createdOn;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Item item = (Item) o;
+        return id == item.id &&
+                Double.compare(item.itemPrice, itemPrice) == 0 &&
+                Objects.equals(itemName, item.itemName) &&
+                itemType == item.itemType &&
+                Objects.equals(createdOn, item.createdOn);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, itemName, itemPrice, itemType, createdOn);
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/persistmaps/mapkey/Order.java

@@ -0,0 +1,44 @@
+package com.baeldung.hibernate.persistmaps.mapkey;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.JoinTable;
+import javax.persistence.MapKey;
+import javax.persistence.OneToMany;
+import javax.persistence.Table;
+import java.util.Map;
+
+@Entity
+@Table(name = "orders")
+public class Order {
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+    @OneToMany(cascade = CascadeType.ALL)
+    @JoinTable(name = "order_item_mapping", joinColumns = {@JoinColumn(name = "order_id", referencedColumnName = "id")},
+            inverseJoinColumns = {@JoinColumn(name = "item_id", referencedColumnName = "id")})
+    @MapKey(name = "itemName")
+    private Map<String, Item> itemMap;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public Map<String, Item> getItemMap() {
+        return itemMap;
+    }
+
+    public void setItemMap(Map<String, Item> itemMap) {
+        this.itemMap = itemMap;
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/persistmaps/mapkey/User.java

@@ -0,0 +1,68 @@
+package com.baeldung.hibernate.persistmaps.mapkey;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.validation.constraints.Size;
+import javax.money.MonetaryAmount;
+
+import org.hibernate.validator.constraints.Length;
+import org.hibernate.validator.constraints.CreditCardNumber;
+import org.hibernate.validator.constraints.Currency;
+
+@Entity
+public class User {
+    @Id
+    @Column(length = 3)
+    private String firstName;
+
+    @Size(min = 3, max = 15)
+    private String middleName;
+
+    @Length(min = 3, max = 15)
+    private String lastName;
+
+    @Column(length = 5)
+    @Size(min = 3, max = 5)
+    private String city;
+
+    public User(String firstName, String middleName, String lastName, String city) {
+        super();
+        this.firstName = firstName;
+        this.middleName = middleName;
+        this.lastName = lastName;
+        this.city = city;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getMiddleName() {
+        return middleName;
+    }
+
+    public void setMiddleName(String middletName) {
+        this.middleName = middletName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    public String getCity() {
+        return city;
+    }
+
+    public void setCity(String city) {
+        this.city = city;
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/persistmaps/mapkeycolumn/Order.java

@@ -0,0 +1,43 @@
+package com.baeldung.hibernate.persistmaps.mapkeycolumn;
+
+import javax.persistence.CollectionTable;
+import javax.persistence.Column;
+import javax.persistence.ElementCollection;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.MapKeyColumn;
+import javax.persistence.Table;
+import java.util.Map;
+
+@Entity
+@Table(name = "orders")
+public class Order {
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+    @ElementCollection
+    @CollectionTable(name = "order_item_mapping", joinColumns = {@JoinColumn(name = "order_id", referencedColumnName = "id")})
+    @MapKeyColumn(name = "item_name")
+    @Column(name = "price")
+    private Map<String, Double> itemPriceMap;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public Map<String, Double> getItemPriceMap() {
+        return itemPriceMap;
+    }
+
+    public void setItemPriceMap(Map<String, Double> itemPriceMap) {
+        this.itemPriceMap = itemPriceMap;
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/persistmaps/mapkeyenumerated/Order.java

@@ -0,0 +1,48 @@
+package com.baeldung.hibernate.persistmaps.mapkeyenumerated;
+
+import com.baeldung.hibernate.persistmaps.ItemType;
+import com.baeldung.hibernate.persistmaps.mapkey.Item;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.JoinTable;
+import javax.persistence.MapKeyEnumerated;
+import javax.persistence.OneToMany;
+import javax.persistence.Table;
+import java.util.Map;
+
+@Entity
+@Table(name = "orders")
+public class Order {
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+    @OneToMany(cascade = CascadeType.ALL)
+    @JoinTable(name = "order_item_mapping", joinColumns = {@JoinColumn(name = "order_id", referencedColumnName = "id")},
+            inverseJoinColumns = {@JoinColumn(name = "item_id", referencedColumnName = "id")})
+    @MapKeyEnumerated(EnumType.STRING)
+    private Map<ItemType, Item> itemMap;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public Map<ItemType, Item> getItemMap() {
+        return itemMap;
+    }
+
+    public void setItemMap(Map<ItemType, Item> itemMap) {
+        this.itemMap = itemMap;
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/persistmaps/mapkeyjoincolumn/Item.java

@@ -0,0 +1,112 @@
+package com.baeldung.hibernate.persistmaps.mapkeyjoincolumn;
+
+import com.baeldung.hibernate.persistmaps.ItemType;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+import java.util.Date;
+import java.util.Objects;
+
+@Entity
+@Table(name = "item")
+public class Item {
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+    @Column(name = "name")
+    private String itemName;
+
+    @Column(name = "price")
+    private double itemPrice;
+
+    @Column(name = "item_type")
+    @Enumerated(EnumType.STRING)
+    private ItemType itemType;
+
+    @Temporal(TemporalType.TIMESTAMP)
+    @Column(name = "created_on")
+    private Date createdOn;
+
+    @ManyToOne(cascade = CascadeType.ALL)
+    @JoinColumn(name = "seller_id")
+    private Seller seller;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getItemName() {
+        return itemName;
+    }
+
+    public void setItemName(String itemName) {
+        this.itemName = itemName;
+    }
+
+    public double getItemPrice() {
+        return itemPrice;
+    }
+
+    public void setItemPrice(double itemPrice) {
+        this.itemPrice = itemPrice;
+    }
+
+    public ItemType getItemType() {
+        return itemType;
+    }
+
+    public void setItemType(ItemType itemType) {
+        this.itemType = itemType;
+    }
+
+    public Date getCreatedOn() {
+        return createdOn;
+    }
+
+    public void setCreatedOn(Date createdOn) {
+        this.createdOn = createdOn;
+    }
+
+    public Seller getSeller() {
+        return seller;
+    }
+
+    public void setSeller(Seller seller) {
+        this.seller = seller;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Item item = (Item) o;
+        return id == item.id &&
+                Double.compare(item.itemPrice, itemPrice) == 0 &&
+                Objects.equals(itemName, item.itemName) &&
+                itemType == item.itemType &&
+                Objects.equals(createdOn, item.createdOn) &&
+                Objects.equals(seller, item.seller);
+    }
+
+    @Override
+    public int hashCode() {
+
+        return Objects.hash(id, itemName, itemPrice, itemType, createdOn, seller);
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/persistmaps/mapkeyjoincolumn/Order.java

@@ -0,0 +1,44 @@
+package com.baeldung.hibernate.persistmaps.mapkeyjoincolumn;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.JoinTable;
+import javax.persistence.MapKeyJoinColumn;
+import javax.persistence.OneToMany;
+import javax.persistence.Table;
+import java.util.Map;
+
+@Entity
+@Table(name = "orders")
+public class Order {
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+    @OneToMany(cascade = CascadeType.ALL)
+    @JoinTable(name = "order_item_mapping", joinColumns = {@JoinColumn(name = "order_id", referencedColumnName = "id")},
+            inverseJoinColumns = {@JoinColumn(name = "item_id", referencedColumnName = "id")})
+    @MapKeyJoinColumn(name = "seller_id")
+    private Map<Seller, Item> sellerItemMap;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public Map<Seller, Item> getSellerItemMap() {
+        return sellerItemMap;
+    }
+
+    public void setSellerItemMap(Map<Seller, Item> sellerItemMap) {
+        this.sellerItemMap = sellerItemMap;
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/persistmaps/mapkeyjoincolumn/Seller.java

@@ -0,0 +1,51 @@
+package com.baeldung.hibernate.persistmaps.mapkeyjoincolumn;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import java.util.Objects;
+
+@Entity
+@Table(name = "seller")
+public class Seller {
+
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+    @Column(name = "name")
+    private String sellerName;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getSellerName() {
+        return sellerName;
+    }
+
+    public void setSellerName(String sellerName) {
+        this.sellerName = sellerName;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Seller seller = (Seller) o;
+        return Objects.equals(sellerName, seller.sellerName);
+    }
+
+    @Override
+    public int hashCode() {
+
+        return Objects.hash(sellerName);
+    }
+}

persistence-modules/hibernate-mapping/src/main/java/com/baeldung/hibernate/persistmaps/mapkeytemporal/Order.java

@@ -0,0 +1,48 @@
+package com.baeldung.hibernate.persistmaps.mapkeytemporal;
+
+import com.baeldung.hibernate.persistmaps.mapkey.Item;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.JoinTable;
+import javax.persistence.MapKeyTemporal;
+import javax.persistence.OneToMany;
+import javax.persistence.Table;
+import javax.persistence.TemporalType;
+import java.util.Date;
+import java.util.Map;
+
+@Entity
+@Table(name = "orders")
+public class Order {
+    @Id
+    @GeneratedValue
+    @Column(name = "id")
+    private int id;
+
+    @OneToMany(cascade = CascadeType.ALL)
+    @JoinTable(name = "order_item_mapping", joinColumns = {@JoinColumn(name = "order_id", referencedColumnName = "id")},
+            inverseJoinColumns = {@JoinColumn(name = "item_id", referencedColumnName = "id")})
+    @MapKeyTemporal(TemporalType.TIMESTAMP)
+    private Map<Date, Item> itemMap;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public Map<Date, Item> getItemMap() {
+        return itemMap;
+    }
+
+    public void setItemMap(Map<Date, Item> itemMap) {
+        this.itemMap = itemMap;
+    }
+}

persistence-modules/hibernate-mapping/src/main/resources/hibernate-annotation.cfg.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE hibernate-configuration PUBLIC
+		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+		"http://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
+<hibernate-configuration>
+    <session-factory>
+        <property name="hibernate.connection.driver_class">org.h2.Driver</property>
+        <property name="hibernate.connection.password"></property>
+        <property name="hibernate.connection.url">jdbc:h2:mem:spring_hibernate_one_to_many</property>
+        <property name="hibernate.connection.username">sa</property>
+        <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
+        <property name="hbm2ddl.auto">create</property>
+        <property name="hibernate.current_session_context_class">thread</property>
+        <property name="hibernate.show_sql">true</property>
+        
+        <mapping class="com.baeldung.hibernate.oneToMany.model.Cart"/>
+        <mapping class="com.baeldung.hibernate.oneToMany.model.Items"/>
+        <mapping class="com.baeldung.hibernate.oneToMany.model.CartOIO"/>
+        <mapping class="com.baeldung.hibernate.oneToMany.model.ItemsOIO"/>
+    </session-factory>
+</hibernate-configuration>

persistence-modules/hibernate-mapping/src/main/resources/hibernate.properties

@@ -0,0 +1,10 @@
+hibernate.connection.driver_class=org.h2.Driver
+hibernate.connection.url=jdbc:h2:mem:mydb1;DB_CLOSE_DELAY=-1
+hibernate.connection.username=sa
+hibernate.connection.autocommit=true
+jdbc.password=
+
+hibernate.dialect=org.hibernate.dialect.H2Dialect
+hibernate.show_sql=true
+hibernate.hbm2ddl.auto=create-drop
+

persistence-modules/hibernate-mapping/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT"/>
+    </root>
+</configuration>

persistence-modules/hibernate-mapping/src/main/resources/one_to_many.sql

@@ -0,0 +1,12 @@
+CREATE TABLE `Cart` (
+  `cart_id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+  PRIMARY KEY (`cart_id`)
+) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
+
+CREATE TABLE `Items` (
+  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+  `cart_id` int(11) unsigned NOT NULL,
+  PRIMARY KEY (`id`),
+  KEY `cart_id` (`cart_id`),
+  CONSTRAINT `items_ibfk_1` FOREIGN KEY (`cart_id`) REFERENCES `Cart` (`cart_id`)
+) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;

persistence-modules/hibernate-mapping/src/test/java/com/baeldung/hibernate/basicannotation/BasicAnnotationIntegrationTest.java

@@ -0,0 +1,60 @@
+package com.baeldung.hibernate.basicannotation;
+
+import java.io.IOException;
+
+import javax.persistence.PersistenceException;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.Transaction;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.baeldung.hibernate.HibernateUtil;
+import com.baeldung.hibernate.Strategy;
+
+public class BasicAnnotationIntegrationTest {
+
+    private static SessionFactory sessionFactory;
+    private Session session;
+    private Transaction transaction;
+
+    @BeforeClass
+    public static void beforeTests() {
+        sessionFactory = HibernateUtil.getSessionFactory(Strategy.MAP_KEY_COLUMN_BASED);
+    }
+
+    @Before
+    public void setUp() throws IOException {
+        session = sessionFactory.openSession();
+        transaction = session.beginTransaction();
+    }
+
+    @After
+    public void tearDown() {
+        transaction.rollback();
+        session.close();
+    }
+
+    @Test
+    public void givenACourse_whenCourseNamePresent_shouldPersist() {
+        Course course = new Course();
+        course.setName("Computers");
+
+        session.save(course);
+        session.flush();
+        session.clear();
+
+    }
+
+    @Test(expected = PersistenceException.class)
+    public void givenACourse_whenCourseNameAbsent_shouldFail() {
+        Course course = new Course();
+
+        session.save(course);
+        session.flush();
+        session.clear();
+    }
+}

persistence-modules/hibernate-mapping/src/test/java/com/baeldung/hibernate/oneToMany/main/HibernateOneToManyAnnotationMainIntegrationTest.java

@@ -0,0 +1,95 @@
+package com.baeldung.hibernate.oneToMany.main;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
+import org.hibernate.cfg.Configuration;
+import org.hibernate.dialect.H2Dialect;
+import org.hibernate.service.ServiceRegistry;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.baeldung.hibernate.oneToMany.model.Cart;
+import com.baeldung.hibernate.oneToMany.model.Items;
+
+public class HibernateOneToManyAnnotationMainIntegrationTest {
+
+	private static SessionFactory sessionFactory;
+
+	private Session session;
+
+	public HibernateOneToManyAnnotationMainIntegrationTest() {
+	}
+
+	@BeforeClass
+	public static void beforeTests() {
+		Configuration configuration = new Configuration().addAnnotatedClass(Cart.class).addAnnotatedClass(Items.class)
+				.setProperty("hibernate.dialect", H2Dialect.class.getName())
+				.setProperty("hibernate.connection.driver_class", org.h2.Driver.class.getName())
+				.setProperty("hibernate.connection.url", "jdbc:h2:mem:test")
+				.setProperty("hibernate.connection.username", "sa").setProperty("hibernate.connection.password", "")
+				.setProperty("hibernate.hbm2ddl.auto", "update");
+		ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
+				.applySettings(configuration.getProperties()).build();
+		sessionFactory = configuration.buildSessionFactory(serviceRegistry);
+	}
+
+	@Before
+	public void setUp() {
+		session = sessionFactory.openSession();
+		session.beginTransaction();
+	}
+
+	@Test
+	public void givenSession_checkIfDatabaseIsEmpty() {
+		Cart cart = (Cart) session.get(Cart.class, new Long(1));
+		assertNull(cart);
+
+	}
+
+	@Test
+	public void givenSession_checkIfDatabaseIsPopulated_afterCommit() {
+		Cart cart = new Cart();
+		Set<Items> cartItems = new HashSet<>();
+		cartItems = cart.getItems();
+		Assert.assertNull(cartItems);
+		Items item1 = new Items();
+		item1.setCart(cart);
+		assertNotNull(item1);
+		Set<Items> itemsSet = new HashSet<Items>();
+		itemsSet.add(item1);
+		assertNotNull(itemsSet);
+		cart.setItems(itemsSet);
+		assertNotNull(cart);
+		session.persist(cart);
+		session.getTransaction().commit();
+		session.close();
+
+		session = sessionFactory.openSession();
+		session.beginTransaction();
+		cart = (Cart) session.get(Cart.class, new Long(1));
+		assertNotNull(cart);
+	}
+
+	@After
+	public void tearDown() {
+		session.getTransaction().commit();
+		session.close();
+	}
+
+	@AfterClass
+	public static void afterTests() {
+		sessionFactory.close();
+	}
+
+}

persistence-modules/hibernate-mapping/src/test/java/com/baeldung/hibernate/persistmaps/MapKeyColumnIntegrationTest.java

@@ -0,0 +1,79 @@
+package com.baeldung.hibernate.persistmaps;
+
+import com.baeldung.hibernate.HibernateUtil;
+import com.baeldung.hibernate.Strategy;
+import com.baeldung.hibernate.persistmaps.mapkeycolumn.Order;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class MapKeyColumnIntegrationTest {
+    private static SessionFactory sessionFactory;
+
+    private Session session;
+
+    @BeforeClass
+    public static void beforeTests() {
+        sessionFactory = HibernateUtil.getSessionFactory(Strategy.MAP_KEY_COLUMN_BASED);
+    }
+
+    @Before
+    public void setUp() {
+        session = sessionFactory.openSession();
+        session.beginTransaction();
+    }
+
+    @Test
+    public void givenData_whenInsertUsingMapKeyColumn_thenPersistMap() {
+        Map<String, Double> itemPriceMap = new HashMap<>();
+        itemPriceMap.put("Wrangler Jeans", 150.0);
+        itemPriceMap.put("Lee Jeans", 180.0);
+
+
+        Order order = new Order();
+        order.setItemPriceMap(itemPriceMap);
+
+        session.persist(order);
+        session.getTransaction().commit();
+
+        assertInsertedData();
+    }
+
+    private void assertInsertedData() {
+        @SuppressWarnings("unchecked")
+        List<Order> orderList = session.createQuery("FROM Order").list();
+
+        assertNotNull(orderList);
+        assertEquals(1, orderList.size());
+
+        Order order = orderList.get(0);
+
+        Map<String, Double> itemPriceMap = order.getItemPriceMap();
+        assertNotNull(itemPriceMap);
+        assertEquals(itemPriceMap.size(), 2);
+        assertEquals((Double) 150.0, itemPriceMap.get("Wrangler Jeans"));
+        assertEquals((Double) 180.0, itemPriceMap.get("Lee Jeans"));
+
+    }
+
+    @After
+    public void tearDown() {
+        session.close();
+    }
+
+    @AfterClass
+    public static void afterTests() {
+        sessionFactory.close();
+    }
+}

persistence-modules/hibernate-mapping/src/test/java/com/baeldung/hibernate/persistmaps/MapKeyEnumeratedIntegrationTest.java

@@ -0,0 +1,95 @@
+package com.baeldung.hibernate.persistmaps;
+
+import com.baeldung.hibernate.HibernateUtil;
+import com.baeldung.hibernate.Strategy;
+import com.baeldung.hibernate.persistmaps.mapkey.Item;
+import com.baeldung.hibernate.persistmaps.mapkeyenumerated.Order;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.time.Instant;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class MapKeyEnumeratedIntegrationTest {
+    private static SessionFactory sessionFactory;
+
+    private Session session;
+
+    @BeforeClass
+    public static void beforeTests() {
+        sessionFactory = HibernateUtil.getSessionFactory(Strategy.MAP_KEY_ENUMERATED_BASED);
+    }
+
+    @Before
+    public void setUp() {
+        session = sessionFactory.openSession();
+        session.beginTransaction();
+    }
+
+    @Test
+    public void givenData_whenInsertUsingMapKeyEnumerated_thenPersistMap() {
+        Item item1 = new Item();
+        item1.setItemName("Wrangler Jeans");
+        item1.setItemPrice(150.0);
+        item1.setItemType(ItemType.JEANS);
+        item1.setCreatedOn(Date.from(Instant.ofEpochSecond(1554926573)));
+
+
+        Item item2 = new Item();
+        item2.setItemName("Armani Tshirts");
+        item2.setItemPrice(180.0);
+        item2.setItemType(ItemType.TSHIRTS);
+        item2.setCreatedOn(Date.from(Instant.ofEpochSecond(1554890573)));
+
+        Map<ItemType, Item> itemMap = new HashMap<>();
+        itemMap.put(item1.getItemType(), item1);
+        itemMap.put(item2.getItemType(), item2);
+
+        Order order = new Order();
+        order.setItemMap(itemMap);
+
+        session.persist(order);
+        session.getTransaction().commit();
+
+        assertInsertedData(item1, item2);
+    }
+
+    private void assertInsertedData(Item expectedItem1, Item expectedItem2) {
+        @SuppressWarnings("unchecked")
+        List<Order> orderList = session.createQuery("FROM Order").list();
+
+        assertNotNull(orderList);
+        assertEquals(1, orderList.size());
+
+        Order order = orderList.get(0);
+
+        Map<ItemType, Item> itemMap = order.getItemMap();
+        assertNotNull(itemMap);
+        assertEquals(2, itemMap.size());
+        assertEquals(expectedItem1, itemMap.get(ItemType.JEANS));
+        assertEquals(expectedItem2, itemMap.get(ItemType.TSHIRTS));
+
+    }
+
+    @After
+    public void tearDown() {
+        session.close();
+    }
+
+    @AfterClass
+    public static void afterTests() {
+        sessionFactory.close();
+    }
+}
+

persistence-modules/hibernate-mapping/src/test/java/com/baeldung/hibernate/persistmaps/MapKeyIntegrationTest.java

@@ -0,0 +1,95 @@
+package com.baeldung.hibernate.persistmaps;
+
+import com.baeldung.hibernate.HibernateUtil;
+import com.baeldung.hibernate.Strategy;
+import com.baeldung.hibernate.persistmaps.mapkey.Item;
+import com.baeldung.hibernate.persistmaps.mapkey.Order;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.time.Instant;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class MapKeyIntegrationTest {
+    private static SessionFactory sessionFactory;
+
+    private Session session;
+
+    @BeforeClass
+    public static void beforeTests() {
+        sessionFactory = HibernateUtil.getSessionFactory(Strategy.MAP_KEY_BASED);
+    }
+
+    @Before
+    public void setUp() {
+        session = sessionFactory.openSession();
+        session.beginTransaction();
+    }
+
+    @Test
+    public void givenData_whenInsertUsingMapKey_thenPersistMap() {
+        Item item1 = new Item();
+        item1.setItemName("Wrangler Jeans");
+        item1.setItemPrice(150.0);
+        item1.setItemType(ItemType.JEANS);
+        item1.setCreatedOn(Date.from(Instant.ofEpochSecond(1554926573)));
+
+
+        Item item2 = new Item();
+        item2.setItemName("Armani Tshirts");
+        item2.setItemPrice(180.0);
+        item2.setItemType(ItemType.TSHIRTS);
+        item2.setCreatedOn(Date.from(Instant.ofEpochSecond(1554890573)));
+
+        Map<String, Item> itemMap = new HashMap<>();
+        itemMap.put(item1.getItemName(), item1);
+        itemMap.put(item2.getItemName(), item2);
+
+        Order order = new Order();
+        order.setItemMap(itemMap);
+
+        session.persist(order);
+        session.getTransaction().commit();
+
+        assertInsertedData(item1, item2);
+    }
+
+    private void assertInsertedData(Item expectedItem1, Item expectedItem2) {
+        @SuppressWarnings("unchecked")
+        List<Order> orderList = session.createQuery("FROM Order").list();
+
+        assertNotNull(orderList);
+        assertEquals(1, orderList.size());
+
+        Order order = orderList.get(0);
+
+        Map<String, Item> itemMap = order.getItemMap();
+        assertNotNull(itemMap);
+        assertEquals(2, itemMap.size());
+        assertEquals(expectedItem1, itemMap.get("Wrangler Jeans"));
+        assertEquals(expectedItem2, itemMap.get("Armani Tshirts"));
+
+    }
+
+    @After
+    public void tearDown() {
+        session.close();
+    }
+
+    @AfterClass
+    public static void afterTests() {
+        sessionFactory.close();
+    }
+}
+

persistence-modules/hibernate-mapping/src/test/java/com/baeldung/hibernate/persistmaps/MapKeyJoinColumnIntegrationTest.java

@@ -0,0 +1,105 @@
+package com.baeldung.hibernate.persistmaps;
+
+import com.baeldung.hibernate.HibernateUtil;
+import com.baeldung.hibernate.Strategy;
+import com.baeldung.hibernate.persistmaps.mapkeyjoincolumn.Item;
+import com.baeldung.hibernate.persistmaps.mapkeyjoincolumn.Order;
+import com.baeldung.hibernate.persistmaps.mapkeyjoincolumn.Seller;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.time.Instant;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class MapKeyJoinColumnIntegrationTest {
+    private static SessionFactory sessionFactory;
+
+    private Session session;
+
+    @BeforeClass
+    public static void beforeTests() {
+        sessionFactory = HibernateUtil.getSessionFactory(Strategy.MAP_KEY_JOIN_COLUMN_BASED);
+    }
+
+    @Before
+    public void setUp() {
+        session = sessionFactory.openSession();
+        session.beginTransaction();
+    }
+
+    @Test
+    public void givenData_whenInsertUsingMapKeyJoinColumn_thenPersistMap() {
+        Seller seller1 = new Seller();
+        seller1.setSellerName("Walmart");
+
+        Item item1 = new Item();
+        item1.setItemName("Wrangler Jeans");
+        item1.setItemPrice(150.0);
+        item1.setItemType(ItemType.JEANS);
+        item1.setCreatedOn(Date.from(Instant.ofEpochSecond(1554926573)));
+        item1.setSeller(seller1);
+
+
+        Seller seller2 = new Seller();
+        seller2.setSellerName("Amazon");
+
+        Item item2 = new Item();
+        item2.setItemName("Armani Tshirts");
+        item2.setItemPrice(180.0);
+        item2.setItemType(ItemType.TSHIRTS);
+        item2.setCreatedOn(Date.from(Instant.ofEpochSecond(1554890573)));
+        item2.setSeller(seller2);
+
+        Map<Seller, Item> itemSellerMap = new HashMap<>();
+        itemSellerMap.put(seller1, item1);
+        itemSellerMap.put(seller2, item2);
+
+        Order order = new Order();
+        order.setSellerItemMap(itemSellerMap);
+
+
+        session.persist(order);
+        session.getTransaction().commit();
+
+        assertInsertedData(seller1, item1, seller2, item2);
+    }
+
+    private void assertInsertedData(Seller seller1, Item expectedItem1, Seller seller2, Item expectedItem2) {
+        @SuppressWarnings("unchecked")
+        List<Order> orderList = session.createQuery("FROM Order").list();
+
+        assertNotNull(orderList);
+        assertEquals(1, orderList.size());
+
+        Order order = orderList.get(0);
+
+        Map<Seller, Item> sellerItemMap = order.getSellerItemMap();
+        assertNotNull(sellerItemMap);
+        assertEquals(2, sellerItemMap.size());
+        assertEquals(expectedItem1, sellerItemMap.get(seller1));
+        assertEquals(expectedItem2, sellerItemMap.get(seller2));
+
+    }
+
+    @After
+    public void tearDown() {
+        session.close();
+    }
+
+    @AfterClass
+    public static void afterTests() {
+        sessionFactory.close();
+    }
+}
+

persistence-modules/hibernate-mapping/src/test/java/com/baeldung/hibernate/persistmaps/MapKeyTemporalIntegrationTest.java

@@ -0,0 +1,96 @@
+package com.baeldung.hibernate.persistmaps;
+
+import com.baeldung.hibernate.HibernateUtil;
+import com.baeldung.hibernate.Strategy;
+import com.baeldung.hibernate.persistmaps.mapkey.Item;
+import com.baeldung.hibernate.persistmaps.mapkeytemporal.Order;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.time.Instant;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class MapKeyTemporalIntegrationTest {
+    private static SessionFactory sessionFactory;
+
+    private Session session;
+
+    @BeforeClass
+    public static void beforeTests() {
+        sessionFactory = HibernateUtil.getSessionFactory(Strategy.MAP_KEY_TEMPORAL_BASED);
+    }
+
+    @Before
+    public void setUp() {
+        session = sessionFactory.openSession();
+        session.beginTransaction();
+    }
+
+    @Test
+    public void givenData_whenInsertUsingMapKeyEnumerated_thenPersistMap() {
+        Date item1CreatedOn = Date.from(Instant.ofEpochSecond(1554926573));
+        Item item1 = new Item();
+        item1.setItemName("Wrangler Jeans");
+        item1.setItemPrice(150.0);
+        item1.setItemType(ItemType.JEANS);
+        item1.setCreatedOn(item1CreatedOn);
+
+
+        Date item2CreatedOn = Date.from(Instant.ofEpochSecond(1554890573));
+        Item item2 = new Item();
+        item2.setItemName("Armani Tshirts");
+        item2.setItemPrice(180.0);
+        item2.setItemType(ItemType.TSHIRTS);
+        item2.setCreatedOn(item2CreatedOn);
+
+        Map<Date, Item> itemMap = new HashMap<>();
+        itemMap.put(item1CreatedOn, item1);
+        itemMap.put(item2CreatedOn, item2);
+
+        Order order = new Order();
+        order.setItemMap(itemMap);
+
+        session.persist(order);
+        session.getTransaction().commit();
+
+        assertInsertedData(item1CreatedOn, item1, item2CreatedOn, item2);
+    }
+
+    private void assertInsertedData(Date item1CreatedOn, Item expectedItem1, Date item2CreatedOn, Item expectedItem2) {
+        @SuppressWarnings("unchecked")
+        List<Order> orderList = session.createQuery("FROM Order").list();
+
+        assertNotNull(orderList);
+        assertEquals(1, orderList.size());
+
+        Order order = orderList.get(0);
+
+        Map<Date, Item> itemMap = order.getItemMap();
+        assertNotNull(itemMap);
+        assertEquals(2, itemMap.size());
+        assertEquals(expectedItem1, itemMap.get(item1CreatedOn));
+        assertEquals(expectedItem2, itemMap.get(item2CreatedOn));
+
+    }
+
+    @After
+    public void tearDown() {
+        session.close();
+    }
+
+    @AfterClass
+    public static void afterTests() {
+        sessionFactory.close();
+    }
+}

persistence-modules/hibernate-mapping/src/test/java/com/baeldung/hibernate/validation/UserAdditionalValidationUnitTest.java

@@ -0,0 +1,290 @@
+package com.baeldung.hibernate.validation;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.math.BigDecimal;
+import java.time.Duration;
+import java.util.Set;
+
+import javax.money.CurrencyContextBuilder;
+import javax.money.Monetary;
+import javax.money.MonetaryAmount;
+import javax.validation.ConstraintViolation;
+import javax.validation.Validation;
+import javax.validation.Validator;
+import javax.validation.ValidatorFactory;
+
+import org.hibernate.validator.constraints.CodePointLength;
+import org.hibernate.validator.constraints.CreditCardNumber;
+import org.hibernate.validator.constraints.Currency;
+import org.hibernate.validator.constraints.Length;
+import org.hibernate.validator.constraints.LuhnCheck;
+import org.hibernate.validator.constraints.Range;
+import org.hibernate.validator.constraints.SafeHtml;
+import org.hibernate.validator.constraints.ScriptAssert;
+import org.hibernate.validator.constraints.URL;
+import org.hibernate.validator.constraints.time.DurationMax;
+import org.hibernate.validator.constraints.time.DurationMin;
+import org.javamoney.moneta.CurrencyUnitBuilder;
+import org.javamoney.moneta.Money;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class UserAdditionalValidationUnitTest {
+
+    private static Validator validator;
+    private Set<ConstraintViolation<AdditionalValidations>> constraintViolations;
+
+    @BeforeClass
+    public static void before() {
+        ValidatorFactory config = Validation.buildDefaultValidatorFactory();
+        validator = config.getValidator();
+    }
+
+    @Test
+    public void whenValidationWithCCNAndNullCCN_thenNoConstraintViolation() {
+    	AdditionalValidations validations = new AdditionalValidations();
+        constraintViolations = validator.validateProperty(validations, "creditCardNumber");
+        assertTrue(constraintViolations.isEmpty());
+    }
+
+    @Test
+    public void whenValidationWithCCNAndValidCCN_thenNoConstraintViolation() {
+        AdditionalValidations validations = new AdditionalValidations();
+        validations.setCreditCardNumber("79927398713");
+        constraintViolations = validator.validateProperty(validations, "creditCardNumber");
+        assertTrue(constraintViolations.isEmpty());
+    }
+
+    @Test
+    public void whenValidationWithCCNAndInvalidCCN_thenConstraintViolation() {
+    	AdditionalValidations validations = new AdditionalValidations();
+        validations.setCreditCardNumber("79927398714");
+        constraintViolations = validator.validateProperty(validations, "creditCardNumber");
+        assertEquals(constraintViolations.size(), 2);
+    }
+    
+    @Test
+    public void whenValidationWithCCNAndValidCCNWithDashes_thenConstraintViolation() {
+    	AdditionalValidations validations = new AdditionalValidations();
+        validations.setCreditCardNumber("7992-7398-713");
+        constraintViolations = validator.validateProperty(validations, "creditCardNumber");
+        assertEquals(1, constraintViolations.size());
+    }
+
+    @Test
+    public void whenValidationWithLenientCCNAndValidCCNWithDashes_thenNoConstraintViolation() {
+    	AdditionalValidations validations = new AdditionalValidations();
+        validations.setLenientCreditCardNumber("7992-7398-713");
+        constraintViolations = validator.validateProperty(validations, "lenientCreditCardNumber");
+        assertTrue(constraintViolations.isEmpty());
+    }
+ 
+    @Test
+    public void whenMonetaryAmountWithRightCurrency_thenNoConstraintViolation() {
+    	AdditionalValidations bean = new AdditionalValidations();
+        bean.setBalance(Money.of(new BigDecimal(100.0), Monetary.getCurrency("EUR")));
+        constraintViolations = validator.validateProperty(bean, "balance");
+        assertEquals(0, constraintViolations.size());
+    }
+    
+    @Test
+    public void whenMonetaryAmountWithWrongCurrency_thenConstraintViolation() {
+    	AdditionalValidations validations = new AdditionalValidations();
+        validations.setBalance(Money.of(new BigDecimal(100.0), Monetary.getCurrency("USD")));
+        constraintViolations = validator.validateProperty(validations, "balance");
+        assertEquals(1, constraintViolations.size());
+    }
+    
+    @Test
+    public void whenDurationShorterThanMin_thenConstraintViolation() {
+    	AdditionalValidations bean = new AdditionalValidations();
+    	bean.setDuration(Duration.ofDays(1).plusHours(1));
+        constraintViolations = validator.validateProperty(bean, "duration");
+        assertEquals(1, constraintViolations.size());
+    }
+    
+    @Test
+    public void whenDurationLongerThanMax_thenConstraintViolation() {
+    	AdditionalValidations bean = new AdditionalValidations();
+    	bean.setDuration(Duration.ofDays(2).plusHours(3));
+        constraintViolations = validator.validateProperty(bean, "duration");
+        assertEquals(1, constraintViolations.size());
+    }
+    
+    @Test
+    public void whenDurationBetweenMinAndMax_thenNoConstraintViolation() {
+    	AdditionalValidations bean = new AdditionalValidations();
+    	bean.setDuration(Duration.ofDays(2));
+        constraintViolations = validator.validateProperty(bean, "duration");
+        assertEquals(0, constraintViolations.size());
+    }
+    
+    @Test
+    public void whenValueBelowRangeMin_thenConstraintViolation() {
+    	AdditionalValidations bean = new AdditionalValidations();
+    	bean.setPercent(new BigDecimal("-1.4"));
+        constraintViolations = validator.validateProperty(bean, "percent");
+        assertEquals(1, constraintViolations.size());
+    }
+    
+    @Test
+    public void whenValueAboveRangeMax_thenConstraintViolation() {
+    	AdditionalValidations bean = new AdditionalValidations();
+    	bean.setPercent(new BigDecimal("100.03"));
+        constraintViolations = validator.validateProperty(bean, "percent");
+        assertEquals(1, constraintViolations.size());
+    }
+    
+    @Test
+    public void whenValueInRange_thenNoConstraintViolation() {
+    	AdditionalValidations bean = new AdditionalValidations();
+    	bean.setPercent(new BigDecimal("53.23"));
+        constraintViolations = validator.validateProperty(bean, "percent");
+        assertEquals(0, constraintViolations.size());
+    }
+
+    @Test
+    public void whenLengthInRange_thenNoConstraintViolation() {
+    	AdditionalValidations bean = new AdditionalValidations();
+    	bean.setSomeString("aaa");
+        constraintViolations = validator.validateProperty(bean, "someString");
+        assertEquals(0, constraintViolations.size());
+    }
+    
+    @Test
+    public void whenCodePointLengthNotInRange_thenConstraintViolation() {
+    	AdditionalValidations bean = new AdditionalValidations();
+    	bean.setSomeString("aa\uD835\uDD0A");
+        constraintViolations = validator.validateProperty(bean, "someString");
+        assertEquals(1, constraintViolations.size());
+    }
+    
+    @Test
+    public void whenValidUrlWithWrongProtocol_thenConstraintViolation() {
+    	AdditionalValidations bean = new AdditionalValidations();
+    	
+    	bean.setUrl("https://www.google.com/");
+        constraintViolations = validator.validateProperty(bean, "url");
+        assertEquals(0, constraintViolations.size());
+    	
+    	bean.setUrl("http://www.google.com/");
+        constraintViolations = validator.validateProperty(bean, "url");
+        assertEquals(1, constraintViolations.size());
+        
+    	bean.setUrl("https://foo:bar");
+        constraintViolations = validator.validateProperty(bean, "url");
+        assertEquals(1, constraintViolations.size());
+    }
+    
+    @Test
+    public void whenScriptAssertFails_thenConstraintViolation() {
+    	AdditionalValidations bean = new AdditionalValidations();
+    	
+    	constraintViolations = validator.validate(bean);
+    	assertEquals(0, constraintViolations.size());
+        
+        bean.setValid(false);
+    	
+        constraintViolations = validator.validate(bean);
+    	assertEquals(1, constraintViolations.size());
+    	
+    	constraintViolations = validator.validateProperty(bean, "valid");
+    	assertEquals(0, constraintViolations.size());
+    }
+
+    @ScriptAssert(lang = "nashorn", script = "_this.valid")
+    public class AdditionalValidations {
+    	private boolean valid = true;
+    	
+        @CreditCardNumber
+        @LuhnCheck(startIndex = 0, endIndex = Integer.MAX_VALUE, checkDigitIndex = -1)
+        private String creditCardNumber;
+
+        @CreditCardNumber(ignoreNonDigitCharacters = true)
+        private String lenientCreditCardNumber;
+
+        @Currency("EUR")
+        private MonetaryAmount balance;
+        
+        @DurationMin(days = 1, hours = 2)
+        @DurationMax(days = 2, hours = 1)
+        private Duration duration;
+        
+        @Range(min = 0, max = 100)
+        private BigDecimal percent;
+        
+        @Length(min = 1, max = 3)
+        @CodePointLength(min = 1, max = 3)
+        private String someString;
+        
+        @URL(protocol = "https")
+        private String url;
+        
+        public String getCreditCardNumber() {
+            return creditCardNumber;
+        }
+
+        public void setCreditCardNumber(String creditCardNumber) {
+            this.creditCardNumber = creditCardNumber;
+        }
+
+        public String getLenientCreditCardNumber() {
+            return lenientCreditCardNumber;
+        }
+
+        public void setLenientCreditCardNumber(String lenientCreditCardNumber) {
+            this.lenientCreditCardNumber = lenientCreditCardNumber;
+        }
+
+        public MonetaryAmount getBalance() {
+            return balance;
+        }
+
+        public void setBalance(MonetaryAmount balance) {
+            this.balance = balance;
+        }
+        
+        public Duration getDuration() {
+			return duration;
+		}
+        
+        public void setDuration(Duration duration) {
+			this.duration = duration;
+		}
+
+		public BigDecimal getPercent() {
+			return percent;
+		}
+
+		public void setPercent(BigDecimal percent) {
+			this.percent = percent;
+		}
+
+		public String getSomeString() {
+			return someString;
+		}
+
+		public void setSomeString(String someString) {
+			this.someString = someString;
+		}
+
+		public String getUrl() {
+			return url;
+		}
+
+		public void setUrl(String url) {
+			this.url = url;
+		}
+
+		public boolean isValid() {
+			return valid;
+		}
+
+		public void setValid(boolean valid) {
+			this.valid = valid;
+		}
+		
+    }
+}

persistence-modules/hibernate-mapping/src/test/java/com/baeldung/hibernate/validation/UserValidationUnitTest.java

@@ -0,0 +1,81 @@
+package com.baeldung.hibernate.validation;
+
+import static org.junit.Assert.assertEquals;
+import java.util.Set;
+import javax.persistence.PersistenceException;
+import javax.validation.ConstraintViolation;
+import javax.validation.Validation;
+import javax.validation.Validator;
+import javax.validation.ValidatorFactory;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import com.baeldung.hibernate.HibernateUtil;
+import com.baeldung.hibernate.Strategy;
+import com.baeldung.hibernate.persistmaps.mapkey.User;
+
+public class UserValidationUnitTest {
+
+    private static Validator validator;
+    private static SessionFactory sessionFactory;
+    private Session session;
+    private Set<ConstraintViolation<User>> constraintViolations;
+
+    @BeforeClass
+    public static void before() {
+        ValidatorFactory config = Validation.buildDefaultValidatorFactory();
+        validator = config.getValidator();
+        sessionFactory = HibernateUtil.getSessionFactory(Strategy.MAP_KEY_BASED);
+    }
+
+    @Before
+    public void setUp() {
+        session = sessionFactory.openSession();
+        session.beginTransaction();
+    }
+
+    @Test
+    public void whenValidationWithSizeAndInvalidMiddleName_thenConstraintViolation() {
+        User user = new User("john", "m", "butler", "japan");
+        constraintViolations = validator.validateProperty(user, "middleName");
+        assertEquals(constraintViolations.size(), 1);
+    }
+
+    @Test
+    public void whenValidationWithSizeAndValidMiddleName_thenNoConstraintViolation() {
+        User user = new User("john", "mathis", "butler", "japan");
+        constraintViolations = validator.validateProperty(user, "middleName");
+        assertEquals(constraintViolations.size(), 0);
+    }
+
+    @Test
+    public void whenValidationWithLengthAndInvalidLastName_thenConstraintViolation() {
+        User user = new User("john", "m", "b", "japan");
+        constraintViolations = validator.validateProperty(user, "lastName");
+        assertEquals(constraintViolations.size(), 1);
+    }
+
+    @Test
+    public void whenValidationWithLengthAndValidLastName_thenNoConstraintViolation() {
+        User user = new User("john", "mathis", "butler", "japan");
+        constraintViolations = validator.validateProperty(user, "lastName");
+        assertEquals(constraintViolations.size(), 0);
+    }
+
+    @Test(expected = PersistenceException.class)
+    public void whenSavingFirstNameWithInvalidFirstName_thenPersistenceException() {
+        User user = new User("john", "mathis", "butler", "japan");
+        session.save(user);
+        session.getTransaction()
+            .commit();
+    }
+
+    @Test
+    public void whenValidationWithSizeAndColumnWithValidCity_thenNoConstraintViolation() {
+        User user = new User("john", "mathis", "butler", "japan");
+        constraintViolations = validator.validateProperty(user, "city");
+        assertEquals(constraintViolations.size(), 0);
+    }
+}