New unit test format

persistence-modules/querydsl/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles:
+- [Intro to Querydsl](http://www.baeldung.com/intro-to-querydsl)
+- [A Guide to Querydsl with JPA](http://www.baeldung.com/querydsl-with-jpa-tutorial)

persistence-modules/querydsl/pom.xml

@@ -0,0 +1,160 @@
+<?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">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung</groupId>
+    <artifactId>querydsl</artifactId>
+    <version>0.1-SNAPSHOT</version>
+    <name>querydsl</name>
+    <packaging>jar</packaging>
+    <url>http://maven.apache.org</url>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../</relativePath>
+    </parent>
+
+    <dependencies>
+        <!-- QueryDSL -->
+
+        <dependency>
+            <groupId>com.querydsl</groupId>
+            <artifactId>querydsl-jpa</artifactId>
+            <version>${querydsl.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.querydsl</groupId>
+            <artifactId>querydsl-apt</artifactId>
+            <version>${querydsl.version}</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <!-- JPA Persistence Dependencies -->
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-entitymanager</artifactId>
+            <version>${hibernate.version}</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.hibernate.javax.persistence</groupId>
+            <artifactId>hibernate-jpa-2.1-api</artifactId>
+            <version>${hibernate-jpa.version}</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-dbcp</groupId>
+            <artifactId>commons-dbcp</artifactId>
+            <version>${commons-dbcp.version}</version>
+            <type>jar</type>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-pool</groupId>
+            <artifactId>commons-pool</artifactId>
+            <version>${commons-pool.version}</version>
+            <type>jar</type>
+            <scope>compile</scope>
+        </dependency>
+
+        <!-- HSQLDB Dependencies -->
+        <dependency>
+            <groupId>org.hsqldb</groupId>
+            <artifactId>hsqldb</artifactId>
+            <version>${hsqldb.version}</version>
+        </dependency>
+
+        <!-- Spring Dependencies -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <version>${spring.version}</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>commons-logging</artifactId>
+                    <groupId>commons-logging</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webmvc</artifactId>
+            <version>${spring.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-orm</artifactId>
+            <version>${spring.version}</version>
+            <type>jar</type>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-aop</artifactId>
+            <version>${spring.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <version>${spring.version}</version>
+            <type>jar</type>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <!-- Compile src folder without annotation processing -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                    <compilerArgument>-proc:none</compilerArgument>
+                </configuration>
+            </plugin>
+
+            <!-- QueryDSL plugin -->
+            <plugin>
+                <groupId>com.mysema.maven</groupId>
+                <artifactId>apt-maven-plugin</artifactId>
+                <version>${apt-maven-plugin.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>process</goal>
+                        </goals>
+                        <configuration>
+                            <outputDirectory>target/generated-sources/java</outputDirectory>
+                            <processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <spring.version>4.3.4.RELEASE</spring.version>
+        <hibernate.version>5.2.5.Final</hibernate.version>
+        <hibernate-jpa.version>1.0.0.Final</hibernate-jpa.version>
+        <querydsl.version>4.1.4</querydsl.version>
+        <hsqldb.version>2.3.4</hsqldb.version>
+        <commons-pool.version>1.6</commons-pool.version>
+        <commons-dbcp.version>1.4</commons-dbcp.version>
+        <apt-maven-plugin.version>1.1.3</apt-maven-plugin.version>
+    </properties>
+
+</project>

persistence-modules/querydsl/src/main/java/org/baeldung/dao/PersonDao.java

@@ -0,0 +1,22 @@
+package org.baeldung.dao;
+
+import java.util.List;
+import java.util.Map;
+
+import org.baeldung.entity.Person;
+
+public interface PersonDao {
+
+    public Person save(Person person);
+
+    public List<Person> findPersonsByFirstnameQueryDSL(String firstname);
+
+    public List<Person> findPersonsByFirstnameAndSurnameQueryDSL(String firstname, String surname);
+
+    public List<Person> findPersonsByFirstnameInDescendingOrderQueryDSL(String firstname);
+
+    public int findMaxAge();
+
+    public Map<String, Integer> findMaxAgeByName();
+
+}

persistence-modules/querydsl/src/main/java/org/baeldung/dao/PersonDaoImpl.java

@@ -0,0 +1,68 @@
+package org.baeldung.dao;
+
+import java.util.List;
+import java.util.Map;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+
+import org.baeldung.entity.Person;
+import org.baeldung.entity.QPerson;
+import org.springframework.stereotype.Repository;
+
+import com.querydsl.core.group.GroupBy;
+import com.querydsl.jpa.impl.JPAQuery;
+
+@Repository
+public class PersonDaoImpl implements PersonDao {
+
+    @PersistenceContext
+    private EntityManager em;
+
+    @Override
+    public Person save(final Person person) {
+        em.persist(person);
+        return person;
+    }
+
+    @Override
+    public List<Person> findPersonsByFirstnameQueryDSL(final String firstname) {
+        final JPAQuery<Person> query = new JPAQuery<>(em);
+        final QPerson person = QPerson.person;
+
+        return query.from(person).where(person.firstname.eq(firstname)).fetch();
+    }
+
+    @Override
+    public List<Person> findPersonsByFirstnameAndSurnameQueryDSL(final String firstname, final String surname) {
+        final JPAQuery<Person> query = new JPAQuery<>(em);
+        final QPerson person = QPerson.person;
+
+        return query.from(person).where(person.firstname.eq(firstname).and(person.surname.eq(surname))).fetch();
+    }
+
+    @Override
+    public List<Person> findPersonsByFirstnameInDescendingOrderQueryDSL(final String firstname) {
+        final JPAQuery<Person> query = new JPAQuery<>(em);
+        final QPerson person = QPerson.person;
+
+        return query.from(person).where(person.firstname.eq(firstname)).orderBy(person.surname.desc()).fetch();
+    }
+
+    @Override
+    public int findMaxAge() {
+        final JPAQuery<Person> query = new JPAQuery<>(em);
+        final QPerson person = QPerson.person;
+
+        return query.from(person).select(person.age.max()).fetchFirst();
+    }
+
+    @Override
+    public Map<String, Integer> findMaxAgeByName() {
+        final JPAQuery<Person> query = new JPAQuery<>(em);
+        final QPerson person = QPerson.person;
+
+        return query.from(person).transform(GroupBy.groupBy(person.firstname).as(GroupBy.max(person.age)));
+    }
+
+}

persistence-modules/querydsl/src/main/java/org/baeldung/entity/Person.java

@@ -0,0 +1,69 @@
+package org.baeldung.entity;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+
+@Entity
+public class Person {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column
+    private String firstname;
+
+    @Column
+    private String surname;
+
+    @Column
+    private int age;
+
+    Person() {
+    }
+
+    public Person(final String firstname, final String surname) {
+        this.firstname = firstname;
+        this.surname = surname;
+    }
+
+    public Person(final String firstname, final String surname, final int age) {
+        this(firstname, surname);
+        this.age = age;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(final Long id) {
+        this.id = id;
+    }
+
+    public String getFirstname() {
+        return firstname;
+    }
+
+    public void setFirstname(final String firstname) {
+        this.firstname = firstname;
+    }
+
+    public String getSurname() {
+        return surname;
+    }
+
+    public void setSurname(final String surname) {
+        this.surname = surname;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(final int age) {
+        this.age = age;
+    }
+}

persistence-modules/querydsl/src/main/java/org/baeldung/querydsl/intro/entities/BlogPost.java

@@ -0,0 +1,56 @@
+/*
+ * (c) Центр ИТ, 2016. Все права защищены.
+ */
+package org.baeldung.querydsl.intro.entities;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.ManyToOne;
+
+@Entity
+public class BlogPost {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    private String title;
+
+    private String body;
+
+    @ManyToOne
+    private User user;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String code) {
+        this.title = code;
+    }
+
+    public String getBody() {
+        return body;
+    }
+
+    public void setBody(String body) {
+        this.body = body;
+    }
+
+    public User getUser() {
+        return user;
+    }
+
+    public void setUser(User user) {
+        this.user = user;
+    }
+}

persistence-modules/querydsl/src/main/java/org/baeldung/querydsl/intro/entities/User.java

@@ -0,0 +1,55 @@
+/*
+ * (c) Центр ИТ, 2016. Все права защищены.
+ */
+package org.baeldung.querydsl.intro.entities;
+
+import java.util.HashSet;
+import java.util.Set;
+import javax.persistence.*;
+
+@Entity
+public class User {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    private String login;
+
+    private Boolean disabled;
+
+    @OneToMany(cascade = CascadeType.PERSIST, mappedBy = "user")
+    private Set<BlogPost> blogPosts = new HashSet<>(0);
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getLogin() {
+        return login;
+    }
+
+    public void setLogin(String name) {
+        this.login = name;
+    }
+
+    public Set<BlogPost> getBlogPosts() {
+        return blogPosts;
+    }
+
+    public void setBlogPosts(Set<BlogPost> blogPosts) {
+        this.blogPosts = blogPosts;
+    }
+
+    public Boolean getDisabled() {
+        return disabled;
+    }
+
+    public void setDisabled(Boolean disabled) {
+        this.disabled = disabled;
+    }
+}

persistence-modules/querydsl/src/main/resources/META-INF/persistence.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<persistence xmlns="http://java.sun.com/xml/ns/persistence"
+             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
+      http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
+             version="2.0">
+
+    <!-- PersistenceUnit for datastore -->
+    <persistence-unit name="default" transaction-type="RESOURCE_LOCAL">
+        <properties>
+            <property name="hibernate.hbm2ddl.auto" value="update" />
+            <property name="hibernate.show_sql" value="true" />
+            <property name="hibernate.transaction.flush_before_completion"
+                      value="true" />
+            <property name="hibernate.cache.provider_class" value="org.hibernate.cache.HashtableCacheProvider" />
+        </properties>
+    </persistence-unit>
+
+    <!-- PersistenceUnit for Intro to QueryDSL -->
+    <persistence-unit name="org.baeldung.querydsl.intro">
+        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
+        <properties>
+            <property name="hibernate.connection.driver_class" value="org.hsqldb.jdbcDriver"/>
+            <property name="hibernate.connection.url" value="jdbc:hsqldb:mem:test"/>
+            <property name="hibernate.connection.username" value="sa"/>
+            <property name="hibernate.connection.password" value=""/>
+            <property name="hibernate.hbm2ddl.auto" value="update"/>
+            <property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect" />
+        </properties>
+    </persistence-unit>
+
+</persistence>

persistence-modules/querydsl/src/main/resources/logback.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>web - %date [%thread] %-5level %logger{36} - %message%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.springframework" level="WARN" />
+    <logger name="org.springframework.transaction" level="WARN" />
+
+    <!-- in order to debug some marshalling issues, this needs to be TRACE -->
+    <logger name="org.springframework.web.servlet.mvc" level="WARN" />
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

persistence-modules/querydsl/src/test/java/org/baeldung/dao/PersonDaoIntegrationTest.java

@@ -0,0 +1,81 @@
+package org.baeldung.dao;
+
+import java.util.Map;
+
+import org.baeldung.entity.Person;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.transaction.TransactionConfiguration;
+import org.springframework.transaction.annotation.Transactional;
+
+import junit.framework.Assert;
+
+@ContextConfiguration("/test-context.xml")
+@RunWith(SpringJUnit4ClassRunner.class)
+@Transactional
+@TransactionConfiguration(defaultRollback = true)
+public class PersonDaoIntegrationTest {
+
+    @Autowired
+    private PersonDao personDao;
+
+    //
+
+    @Test
+    public void testCreation() {
+        personDao.save(new Person("Erich", "Gamma"));
+        final Person person = new Person("Kent", "Beck");
+        personDao.save(person);
+        personDao.save(new Person("Ralph", "Johnson"));
+
+        final Person personFromDb = personDao.findPersonsByFirstnameQueryDSL("Kent").get(0);
+        Assert.assertEquals(person.getId(), personFromDb.getId());
+    }
+
+    @Test
+    public void testMultipleFilter() {
+        personDao.save(new Person("Erich", "Gamma"));
+        final Person person = personDao.save(new Person("Ralph", "Beck"));
+        final Person person2 = personDao.save(new Person("Ralph", "Johnson"));
+
+        final Person personFromDb = personDao.findPersonsByFirstnameAndSurnameQueryDSL("Ralph", "Johnson").get(0);
+        Assert.assertNotSame(person.getId(), personFromDb.getId());
+        Assert.assertEquals(person2.getId(), personFromDb.getId());
+    }
+
+    @Test
+    public void testOrdering() {
+        final Person person = personDao.save(new Person("Kent", "Gamma"));
+        personDao.save(new Person("Ralph", "Johnson"));
+        final Person person2 = personDao.save(new Person("Kent", "Zivago"));
+
+        final Person personFromDb = personDao.findPersonsByFirstnameInDescendingOrderQueryDSL("Kent").get(0);
+        Assert.assertNotSame(person.getId(), personFromDb.getId());
+        Assert.assertEquals(person2.getId(), personFromDb.getId());
+    }
+
+    @Test
+    public void testMaxAge() {
+        personDao.save(new Person("Kent", "Gamma", 20));
+        personDao.save(new Person("Ralph", "Johnson", 35));
+        personDao.save(new Person("Kent", "Zivago", 30));
+
+        final int maxAge = personDao.findMaxAge();
+        Assert.assertTrue(maxAge == 35);
+    }
+
+    @Test
+    public void testMaxAgeByName() {
+        personDao.save(new Person("Kent", "Gamma", 20));
+        personDao.save(new Person("Ralph", "Johnson", 35));
+        personDao.save(new Person("Kent", "Zivago", 30));
+
+        final Map<String, Integer> maxAge = personDao.findMaxAgeByName();
+        Assert.assertTrue(maxAge.size() == 2);
+        Assert.assertSame(35, maxAge.get("Ralph"));
+        Assert.assertSame(30, maxAge.get("Kent"));
+    }
+}

persistence-modules/querydsl/src/test/java/org/baeldung/querydsl/intro/QueryDSLIntegrationTest.java

@@ -0,0 +1,215 @@
+/*
+ * (c) Центр ИТ, 2016. Все права защищены.
+ */
+package org.baeldung.querydsl.intro;
+
+import com.querydsl.core.Tuple;
+import com.querydsl.core.types.dsl.Expressions;
+import com.querydsl.core.types.dsl.NumberPath;
+import com.querydsl.jpa.JPAExpressions;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import org.baeldung.querydsl.intro.entities.BlogPost;
+import org.baeldung.querydsl.intro.entities.QBlogPost;
+import org.baeldung.querydsl.intro.entities.QUser;
+import org.baeldung.querydsl.intro.entities.User;
+import org.junit.*;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class QueryDSLIntegrationTest {
+
+    private static EntityManagerFactory emf;
+
+    private EntityManager em;
+
+    private JPAQueryFactory queryFactory;
+
+    @BeforeClass
+    public static void populateDatabase() {
+        emf = Persistence.createEntityManagerFactory("org.baeldung.querydsl.intro");
+        EntityManager em = emf.createEntityManager();
+
+        em.getTransaction().begin();
+        User user1 = new User();
+        user1.setLogin("David");
+        em.persist(user1);
+
+        User user2 = new User();
+        user2.setLogin("Ash");
+        em.persist(user2);
+
+        User user3 = new User();
+        user3.setLogin("Call");
+        em.persist(user3);
+
+        User user4 = new User();
+        user4.setLogin("Bishop");
+        em.persist(user4);
+
+        BlogPost blogPost1 = new BlogPost();
+        blogPost1.setTitle("Hello World!");
+        blogPost1.setUser(user1);
+        em.persist(blogPost1);
+
+        BlogPost blogPost2 = new BlogPost();
+        blogPost2.setTitle("My Second Post");
+        blogPost2.setUser(user1);
+        em.persist(blogPost2);
+
+        BlogPost blogPost3 = new BlogPost();
+        blogPost3.setTitle("Hello World!");
+        blogPost3.setUser(user3);
+        em.persist(blogPost3);
+
+        em.getTransaction().commit();
+
+        em.close();
+
+    }
+
+    @Before
+    public void setUp() {
+        em = emf.createEntityManager();
+        em.getTransaction().begin();
+        queryFactory = new JPAQueryFactory(em);
+    }
+
+    @Test
+    public void whenFindByLogin_thenShouldReturnUser() {
+
+        QUser user = QUser.user;
+        User aUser = queryFactory.selectFrom(user)
+                .where(user.login.eq("David"))
+                .fetchOne();
+
+        assertNotNull(aUser);
+        assertEquals(aUser.getLogin(), "David");
+
+    }
+
+    @Test
+    public void whenUsingOrderBy_thenResultsShouldBeOrdered() {
+
+        QUser user = QUser.user;
+        List<User> users = queryFactory.selectFrom(user)
+                .orderBy(user.login.asc())
+                .fetch();
+
+        assertEquals(users.size(), 4);
+        assertEquals(users.get(0).getLogin(), "Ash");
+        assertEquals(users.get(1).getLogin(), "Bishop");
+        assertEquals(users.get(2).getLogin(), "Call");
+        assertEquals(users.get(3).getLogin(), "David");
+
+    }
+
+    @Test
+    public void whenGroupingByTitle_thenReturnsTuples() {
+
+        QBlogPost blogPost = QBlogPost.blogPost;
+
+        NumberPath<Long> count = Expressions.numberPath(Long.class, "c");
+
+        List<Tuple> userTitleCounts = queryFactory.select(blogPost.title, blogPost.id.count().as(count))
+                .from(blogPost)
+                .groupBy(blogPost.title)
+                .orderBy(count.desc())
+                .fetch();
+
+        assertEquals("Hello World!", userTitleCounts.get(0).get(blogPost.title));
+        assertEquals(new Long(2), userTitleCounts.get(0).get(count));
+
+        assertEquals("My Second Post", userTitleCounts.get(1).get(blogPost.title));
+        assertEquals(new Long(1), userTitleCounts.get(1).get(count));
+
+    }
+
+    @Test
+    public void whenJoiningWithCondition_thenResultCountShouldMatch() {
+
+        QUser user = QUser.user;
+        QBlogPost blogPost = QBlogPost.blogPost;
+
+        List<User> users = queryFactory.selectFrom(user)
+                .innerJoin(user.blogPosts, blogPost)
+                .on(blogPost.title.eq("Hello World!"))
+                .fetch();
+
+        assertEquals(2, users.size());
+    }
+
+    @Test
+    public void whenRefiningWithSubquery_thenResultCountShouldMatch() {
+
+        QUser user = QUser.user;
+        QBlogPost blogPost = QBlogPost.blogPost;
+
+        List<User> users = queryFactory.selectFrom(user)
+                .where(user.id.in(
+                        JPAExpressions.select(blogPost.user.id)
+                                .from(blogPost)
+                                .where(blogPost.title.eq("Hello World!"))))
+                .fetch();
+
+        assertEquals(2, users.size());
+    }
+
+    @Test
+    public void whenUpdating_thenTheRecordShouldChange() {
+
+        QUser user = QUser.user;
+
+        queryFactory.update(user)
+                .where(user.login.eq("Ash"))
+                .set(user.login, "Ash2")
+                .set(user.disabled, true)
+                .execute();
+
+        em.getTransaction().commit();
+
+        em.getTransaction().begin();
+
+        assertEquals(Boolean.TRUE,
+                queryFactory.select(user.disabled)
+                        .from(user)
+                        .where(user.login.eq("Ash2"))
+                        .fetchOne());
+
+    }
+
+    @Test
+    public void whenDeleting_thenTheRecordShouldBeAbsent() {
+
+        QUser user = QUser.user;
+
+        queryFactory.delete(user)
+                .where(user.login.eq("Bishop"))
+                .execute();
+
+        em.getTransaction().commit();
+
+        em.getTransaction().begin();
+
+        assertNull(queryFactory.selectFrom(user)
+                .where(user.login.eq("Bishop"))
+                .fetchOne());
+
+    }
+
+    @After
+    public void tearDown() {
+        em.getTransaction().commit();
+        em.close();
+    }
+
+    @AfterClass
+    public static void afterClass() {
+        emf.close();
+    }
+
+}

persistence-modules/querydsl/src/test/resources/db.properties

@@ -0,0 +1,6 @@
+#In memory db
+db.username=sa
+db.password=
+db.driver=org.hsqldb.jdbcDriver
+db.url=jdbc:hsqldb:mem:app-db
+db.dialect=org.hibernate.dialect.HSQLDialect

persistence-modules/querydsl/src/test/resources/test-context.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
+       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
+       xmlns:sec="http://www.springframework.org/schema/security"
+       xmlns:aop="http://www.springframework.org/schema/aop"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
+		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
+		http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.xsd
+		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
+		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"
+        >
+
+    <tx:annotation-driven />
+    <context:component-scan base-package="org.baeldung" />
+
+    <import resource="test-db.xml" />
+
+</beans>

persistence-modules/querydsl/src/test/resources/test-db.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:mvc="http://www.springframework.org/schema/mvc"
+       xmlns:context="http://www.springframework.org/schema/context"
+       xmlns:tx="http://www.springframework.org/schema/tx"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
+		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
+		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd" default-autowire="byName">
+
+    <bean id="placeholderConfig"
+          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
+        <property name="locations">
+            <list>
+                <value>classpath:db.properties</value>
+            </list>
+        </property>
+    </bean>
+
+    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" name="EntityManagerFactory">
+        <property name="persistenceUnitName" value="default"></property>
+        <property name="dataSource" ref="dataSource"></property>
+        <property name="jpaVendorAdapter">
+            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
+                <property name="showSql" value="true" />
+                <property name="generateDdl" value="true" />
+                <property name="databasePlatform" value="${db.dialect}" />
+            </bean>
+        </property>
+    </bean>
+
+    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
+          destroy-method="close">
+        <property name="driverClassName" value="${db.driver}" />
+        <property name="url" value="${db.url}" />
+        <property name="username" value="${db.username}" />
+        <property name="password" value="${db.password}" />
+    </bean>
+
+    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager" name="TransactionManager">
+        <property name="entityManagerFactory" ref="entityManagerFactory"></property>
+    </bean>
+
+    <tx:annotation-driven />
+
+    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
+
+</beans>