Eliminated AbstractDatabaseTest, replaced with Spring Configuration.

src/main/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/business/EventBusiness.java

@@ -22,7 +22,7 @@ public class EventBusiness {
 	private final Logger log = LoggerFactory.getLogger(getClass());
 
 	@Autowired
-	ClubEventDao dao;
+	ClubEventDao clubEventDao;
 
 	@Autowired
 	AltersgruppeDao altersgruppeDao;
@@ -30,7 +30,7 @@ public class EventBusiness {
 	private ClubEvent current;
 
 	public synchronized List<ClubEvent> loadEvents() {
-		List<ClubEvent> list = dao.listAll();
+		List<ClubEvent> list = clubEventDao.listAll();
 		log.trace("Returning events from database: {}", list);
 		return list;
 	}
@@ -46,7 +46,7 @@ public class EventBusiness {
 	public void changePersons(Set<Person> selected) {
 		if (current != null) {
 			try {
-				dao.addPersons(current, selected);
+				clubEventDao.addPersons(current, selected);
 				log.info("Updated {}, {} with participants: {}", current.getCaption(), current.getStart(), selected);
 			} catch (Exception e) {
 				log.error("Unable to update Event {}, {}, {} with participants: {}", current.getId(),
@@ -79,7 +79,7 @@ public class EventBusiness {
 
 	public void storeAltersgruppe(Altersgruppe edited) {
 		altersgruppeDao.save(edited);
-		dao.update(current);
+		clubEventDao.update(current);
 	}
 
 	public EventMeldung createMeldung() {

src/main/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/dao/AbstractDaoImpl.java

@@ -13,7 +13,7 @@ import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.EntityAccessor;
 public abstract class AbstractDaoImpl<T extends EntityAccessor> implements IDao<T> {
 
 	@Autowired
-	protected EntityManager em;
+	protected EntityManager entityManager;
 
 	private final Class<T> entityClass;
 
@@ -26,27 +26,27 @@ public abstract class AbstractDaoImpl<T extends EntityAccessor> implements IDao<
 	@Transactional
 	public void save(T obj) {
 
-		if (em.contains(obj) || obj.hasValidId()) {
-			em.merge(obj);
+		if (entityManager.contains(obj) || obj.hasValidId()) {
+			entityManager.merge(obj);
 		} else {
-			em.persist(obj);
+			entityManager.persist(obj);
 		}
 	}
 
 	@Override
 	@Transactional
 	public T update(T obj) {
-		return em.merge(obj);
+		return entityManager.merge(obj);
 	}
 
 	@Override
 	public T get(Object primaryKey) {
-		return em.find(entityClass, primaryKey);
+		return entityManager.find(entityClass, primaryKey);
 	}
 
 	@Override
 	public List<T> listAll() {
-		TypedQuery<T> query = em.createNamedQuery(entityClass.getSimpleName() + ".findAll", entityClass);
+		TypedQuery<T> query = entityManager.createNamedQuery(entityClass.getSimpleName() + ".findAll", entityClass);
 		return query.getResultList();
 	}
 

src/main/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/dao/ClubEventDao.java

@@ -2,17 +2,11 @@ package de.kreth.vaadin.clubhelper.vaadinclubhelper.dao;
 
 import java.util.Collection;
 
-import javax.persistence.EntityManager;
-
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubEvent;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Person;
 
 public interface ClubEventDao extends IDao<ClubEvent> {
 
-	void setEntityManager(EntityManager em);
-
-	EntityManager getEntityManager();
-
 	/**
 	 * Updates Event with participants, {@link ClubEvent} and {@link Person} must be
 	 * persistent already.

src/main/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/dao/ClubEventDaoImpl.java

@@ -6,7 +6,6 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-import javax.persistence.EntityManager;
 import javax.persistence.Query;
 
 import org.springframework.stereotype.Repository;
@@ -23,16 +22,6 @@ public class ClubEventDaoImpl extends AbstractDaoImpl<ClubEvent> implements Club
 		super(ClubEvent.class);
 	}
 
-	@Override
-	public void setEntityManager(EntityManager em) {
-		this.em = em;
-	}
-
-	@Override
-	public EntityManager getEntityManager() {
-		return em;
-	}
-
 	@Override
 	public void addPersons(ClubEvent event, Collection<Person> updated) {
 		List<Person> added = new ArrayList<>(updated);
@@ -48,7 +37,7 @@ public class ClubEventDaoImpl extends AbstractDaoImpl<ClubEvent> implements Club
 			}
 		}
 
-		Query insertQuery = em.createNativeQuery(
+		Query insertQuery = entityManager.createNativeQuery(
 				"INSERT INTO clubevent_has_person (clubevent_id, person_id) VALUES (:eventId,:personId)");
 		for (Person p : added) {
 			insertQuery.setParameter("eventId", event.getId());

src/main/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/dao/PersonDaoImpl.java

@@ -15,7 +15,7 @@ public class PersonDaoImpl extends AbstractDaoImpl<Person> implements PersonDao
 
 	@Override
 	public Person findLoginUser(String username, String password) {
-		TypedQuery<Person> query = em.createNamedQuery(Person.QUERY_FINDLOGIN, Person.class);
+		TypedQuery<Person> query = entityManager.createNamedQuery(Person.QUERY_FINDLOGIN, Person.class);
 		query.setParameter("username", username);
 		query.setParameter("password", password);
 		return query.getSingleResult();

src/main/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/data/ClubEvent.java

@@ -11,6 +11,7 @@ import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.JoinColumn;
 import javax.persistence.ManyToMany;
+import javax.persistence.OneToMany;
 import javax.persistence.OneToOne;
 import javax.persistence.Transient;
 
@@ -30,6 +31,7 @@ public class ClubEvent extends BasicItem implements EntityAccessor {
 	private String organizerDisplayName;
 	@ManyToMany
 	private Set<Person> persons;
+	@OneToMany
 	private Set<Altersgruppe> altersgruppen;
 	@OneToOne
 	@JoinColumn(name = "id", nullable = true)

src/test/java/de/kreth/vaadin/clubhelper/AbstractHibernateConfiguration.java

@@ -17,7 +17,7 @@ import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Startpass;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.StartpassStartrechte;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Version;
 
-public class AbstractHibernateConfiguration implements HibernateConfiguration {
+public abstract class AbstractHibernateConfiguration implements HibernateConfiguration {
 
 	@Override
 	public void configure(Configuration configuration) {

src/test/java/de/kreth/vaadin/clubhelper/HibernateHolder.java

@@ -8,14 +8,12 @@ import org.hibernate.cfg.Configuration;
 public enum HibernateHolder {
 
 	INSTANCE;
-	private final Configuration configuration = createConfig();
+	private final Configuration configuration;
 
-	private org.hibernate.cfg.Configuration createConfig() {
-		Configuration configuration = new Configuration();
+	private HibernateHolder() {
+		configuration = new Configuration();
 		HibernateConfiguration config = new H2MemoryConfiguration();
 		config.configure(configuration);
-
-		return configuration;
 	}
 
 	public static Properties getProperties() {
@@ -26,7 +24,4 @@ public enum HibernateHolder {
 		return INSTANCE.configuration.buildSessionFactory();
 	}
 
-//	public static Configuration configuration() {
-//		return INSTANCE.configuration;
-//	}
 }

src/test/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/business/EventBusinessSpringTest.java

@@ -7,12 +7,10 @@ import java.time.LocalDate;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
-import java.util.function.Consumer;
 
 import javax.persistence.EntityManager;
 import javax.persistence.TypedQuery;
 
-import org.hibernate.Session;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Disabled;
@@ -22,8 +20,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 
-import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.AbstractDatabaseTest;
-import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.AbstractDatabaseTest.DB_TYPE;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.TestDatabaseHelper;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubEvent;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubeventHasPerson;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Person;
@@ -42,6 +39,9 @@ class EventBusinessSpringTest {
 	@Autowired
 	private EntityManager entityManager;
 
+	@Autowired
+	private TestDatabaseHelper testDatabaseHelper;
+
 	private TypedQuery<ClubeventHasPerson> all;
 
 	@BeforeEach
@@ -55,7 +55,7 @@ class EventBusinessSpringTest {
 	@AfterEach
 	void shutdown() {
 		entityManager.clear();
-		((Session) entityManager).doWork(conn -> AbstractDatabaseTest.cleanDatabase(conn, DB_TYPE.H2));
+		testDatabaseHelper.cleanDatabase();
 	}
 
 	private void insertTestData() {
@@ -71,7 +71,7 @@ class EventBusinessSpringTest {
 			entityManager.persist(p);
 			persons.add(p);
 		}
-		event = AbstractDatabaseTest.creteEvent();
+		event = testDatabaseHelper.creteEvent();
 		assertNull(event.getPersons());
 		entityManager.persist(event);
 		entityManager.getTransaction().commit();
@@ -107,23 +107,4 @@ class EventBusinessSpringTest {
 		assertEquals(2, result.size());
 	}
 
-	class DatabaseHelper extends AbstractDatabaseTest {
-		public DatabaseHelper(EntityManager em) {
-			this((Session) em);
-		}
-
-		public DatabaseHelper(Session session) {
-			this.session = session;
-		}
-
-		@Override
-		public void transactional(Runnable r) {
-			super.transactional(r);
-		}
-
-		@Override
-		public void transactional(Consumer<Session> r) {
-			super.transactional(r);
-		}
-	}
 }

src/test/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/business/EventBusinessTest.java

@@ -42,7 +42,7 @@ class EventBusinessTest {
 	void setUp() throws Exception {
 		MockitoAnnotations.initMocks(this);
 		eventBusiness = new EventBusiness();
-		eventBusiness.dao = dao;
+		eventBusiness.clubEventDao = dao;
 		eventBusiness.altersgruppeDao = altersgruppeDao;
 	}
 

src/test/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/dao/ClubEventDataTest.java

@@ -9,32 +9,49 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-import org.hibernate.IdentifierLoadAccess;
-import org.hibernate.query.Query;
+import javax.persistence.EntityManager;
+
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ContextConfiguration;
 
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubEvent;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubeventHasPerson;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Person;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.ui.tests.TestConfiguration;
+
+@SpringBootTest
+@ContextConfiguration(classes = TestConfiguration.class)
+public class ClubEventDataTest {
+
+	@Autowired
+	private EntityManager entityManager;
 
-public class ClubEventDataTest extends AbstractDatabaseTest {
+	@Autowired
+	TestDatabaseHelper testDatabaseHelper;
+
+	@AfterEach
+	public void cleanDatabase() {
+		testDatabaseHelper.cleanDatabase();
+	}
 
 	@Test
 	public void testSaveAndSelectEvent() {
-		ClubEvent ev = creteEvent();
+		ClubEvent ev = testDatabaseHelper.creteEvent();
 
-		transactional(() -> session.save(ev));
-		Query<ClubEvent> query = session.createNamedQuery("ClubEvent.findAll", ClubEvent.class);
-		List<ClubEvent> result = query.list();
+		testDatabaseHelper.transactional(() -> entityManager.persist(ev));
+		List<ClubEvent> result = testDatabaseHelper.allClubEvent();
 		assertEquals(1, result.size());
 	}
 
 	@Test
 	public void testEventWithPerson() {
 
-		ClubEvent ev = creteEvent();
+		ClubEvent ev = testDatabaseHelper.creteEvent();
 
-		Person person = testInsertPerson();
+		Person person = testDatabaseHelper.testInsertPerson();
 		Set<Person> persons = ev.getPersons();
 		if (persons == null) {
 			persons = new HashSet<>();
@@ -42,9 +59,9 @@ public class ClubEventDataTest extends AbstractDatabaseTest {
 		}
 		persons.add(person);
 
-		transactional(() -> session.save(ev));
+		testDatabaseHelper.transactional(() -> entityManager.persist(ev));
 
-		List<ClubeventHasPerson> loadEventPersons = loadEventPersons();
+		List<ClubeventHasPerson> loadEventPersons = testDatabaseHelper.loadEventPersons();
 		assertFalse(loadEventPersons.isEmpty());
 		ClubeventHasPerson link = loadEventPersons.get(0);
 		assertEquals(person.getId(), link.getPersonId());
@@ -54,62 +71,60 @@ public class ClubEventDataTest extends AbstractDatabaseTest {
 
 	@Test
 	public void changeEventsPersons() {
-		ClubEvent ev = creteEvent();
+		ClubEvent ev = testDatabaseHelper.creteEvent();
 
-		transactional(() -> session.save(ev));
+		testDatabaseHelper.transactional(() -> entityManager.persist(ev));
 
-		Person person = testInsertPerson();
+		Person person = testDatabaseHelper.testInsertPerson();
 
 		Person person2 = new Person();
-		person2.setId(person.getId() + 1);
 		person2.setPrename(person.getPrename() + "_2");
 		person2.setSurname(person.getSurname() + "_2");
 		person2.setBirth(LocalDate.now());
 
-		transactional(() -> session.save(person2));
+		testDatabaseHelper.transactional(() -> entityManager.persist(person2));
 
-		IdentifierLoadAccess<ClubEvent> idLoadAccess = session.byId(ClubEvent.class);
-		ClubEvent loaded = idLoadAccess.load(ev.getId());
+		ClubEvent loaded = entityManager.find(ClubEvent.class, ev.getId());
 		assertNotNull(loaded);
 		if (loaded.getPersons() == null) {
 			loaded.setPersons(new HashSet<>());
 		}
 
 		loaded.add(person);
-		transactional(() -> session.update(ev));
+		testDatabaseHelper.transactional(() -> entityManager.merge(ev));
 
 		loaded.add(person2);
-		transactional(() -> session.update(ev));
+		testDatabaseHelper.transactional(() -> entityManager.merge(ev));
 
-		List<ClubeventHasPerson> entries = loadEventPersons();
+		List<ClubeventHasPerson> entries = testDatabaseHelper.loadEventPersons();
 		assertEquals(2, entries.size());
 	}
 
 	@Test
 	public void testChangeEventParticipantsRapidly() {
 
-		final ClubEvent created = creteEvent();
-		transactional(() -> {
-			session.save(created);
+		final ClubEvent created = testDatabaseHelper.creteEvent();
+		testDatabaseHelper.transactional(() -> {
+			entityManager.persist(created);
 		});
 
-		final ClubEvent ev = session.byId(ClubEvent.class).load(created.getId());
-		List<Person> persons = insertPersons(6);
+		final ClubEvent ev = entityManager.find(ClubEvent.class, created.getId());
+		List<Person> persons = testDatabaseHelper.insertPersons(6);
 		for (Person p : persons) {
 			ev.add(p);
-			transactional(() -> session.merge(ev));
+			testDatabaseHelper.transactional(() -> entityManager.merge(ev));
 		}
 		ev.remove(persons.get(2));
-		transactional(() -> session.merge(ev));
+		testDatabaseHelper.transactional(() -> entityManager.merge(ev));
 
 		ev.remove(persons.get(4));
-		transactional(() -> session.merge(ev));
+		testDatabaseHelper.transactional(() -> entityManager.merge(ev));
 
 		ev.getPersons().add(persons.get(2));
 		ev.getPersons().add(persons.get(4));
-		transactional(() -> session.merge(ev));
+		testDatabaseHelper.transactional(() -> entityManager.merge(ev));
 
-		List<ClubeventHasPerson> result = loadEventPersons();
+		List<ClubeventHasPerson> result = testDatabaseHelper.loadEventPersons();
 		assertEquals(6, result.size());
 	}
 

src/test/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/dao/PersonDaoTest.java

@@ -5,20 +5,13 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 import java.io.IOException;
-import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
 import java.time.LocalDate;
 import java.util.List;
 
 import javax.persistence.EntityManager;
-import javax.persistence.EntityTransaction;
-import javax.persistence.Query;
-import javax.persistence.TypedQuery;
 
-import org.apache.commons.io.IOUtils;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
@@ -33,44 +26,36 @@ public class PersonDaoTest {
 
 	@Autowired
 	private PersonDao personDao;
+
 	@Autowired
 	private EntityManager entityManager;
 
-	private Person person;
-	private TypedQuery<Person> q;
+	@Autowired
+	private TestDatabaseHelper testDatabaseHelper;
 
-	private final String truncateString = createTruncateString();
+	private Person person;
 
 	@BeforeEach
 	public void setUp() throws Exception {
+		testDatabaseHelper.cleanDatabase();
 		person = new Person();
 		person.setPrename("prename");
 		person.setSurname("surname");
 		person.setBirth(LocalDate.of(2018, 11, 8));
 		person.setPassword("password");
-		q = entityManager.createNamedQuery(Person.QUERY_FINDALL, Person.class);
-		assertTrue(q.getResultList().isEmpty());
+		assertTrue(entityManager.createNamedQuery(Person.QUERY_FINDALL, Person.class).getResultList().isEmpty());
 	}
 
 	@AfterEach
 	public void clearDatabase() throws IOException {
-		Query truncateQuery = entityManager.createNativeQuery(truncateString);
-		transactional(() -> truncateQuery.executeUpdate());
-	}
-
-	private String createTruncateString() {
-		try {
-			InputStream resource = getClass().getResourceAsStream("/truncateTables.sql");
-			return IOUtils.toString(resource, StandardCharsets.UTF_8);
-		} catch (IOException e) {
-			throw new RuntimeException(e);
-		}
+		testDatabaseHelper.cleanDatabase();
 	}
 
 	@Test
 	public void testSave() {
-		transactional(() -> personDao.save(person));
-		List<Person> stored = q.getResultList();
+		testDatabaseHelper.transactional(() -> personDao.save(person));
+
+		List<Person> stored = entityManager.createNamedQuery(Person.QUERY_FINDALL, Person.class).getResultList();
 		assertEquals(1, stored.size());
 		assertEquals(person, stored.get(0));
 		assertEquals(person, personDao.get(person.getId()));
@@ -80,37 +65,28 @@ public class PersonDaoTest {
 	@Test
 	public void testUpdate() {
 
-		transactional(() -> personDao.save(person));
+		testDatabaseHelper.transactional(() -> personDao.save(person));
 		person.setSurname("surname2");
 		person.setPrename("prename2");
 
-		transactional(() -> personDao.update(person));
+		testDatabaseHelper.transactional(() -> personDao.update(person));
 
-		List<Person> stored = q.getResultList();
+		List<Person> stored = entityManager.createNamedQuery(Person.QUERY_FINDALL, Person.class).getResultList();
 		assertEquals(1, stored.size());
 		assertEquals(person, stored.get(0));
 	}
 
-	public void transactional(Runnable r) {
-		EntityTransaction tx = entityManager.getTransaction();
-		tx.begin();
-		r.run();
-		tx.commit();
-	}
-
-	@Disabled
 	@Test
 	public void testListAll() {
-		transactional(() -> personDao.save(person));
-		entityManager.detach(person);
+		testDatabaseHelper.transactional(() -> personDao.save(person));
 
 		person = new Person();
-		person.setId(0);
 		person.setSurname("surname2");
 		person.setPrename("prename2");
 		person.setBirth(LocalDate.of(2018, 11, 8));
 		person.setPassword("password");
-		transactional(() -> personDao.save(person));
+
+		testDatabaseHelper.transactional(() -> personDao.save(person));
 		List<Person> stored = personDao.listAll();
 		assertEquals(2, stored.size());
 

src/test/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/dao/TestDatabaseHelper.java

@@ -0,0 +1,36 @@
+package de.kreth.vaadin.clubhelper.vaadinclubhelper.dao;
+
+import java.util.List;
+import java.util.function.Consumer;
+
+import org.hibernate.Session;
+
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubEvent;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubeventHasPerson;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Person;
+
+public interface TestDatabaseHelper {
+
+	/**
+	 * executes the given runnable within a jpa Transaction.
+	 * 
+	 * @param r
+	 */
+	void transactional(Runnable r);
+
+	void transactional(Consumer<Session> r);
+
+	List<Person> insertPersons(int count);
+
+	List<Person> createPersons(int count);
+
+	ClubEvent creteEvent();
+
+	List<ClubeventHasPerson> loadEventPersons();
+
+	List<ClubEvent> allClubEvent();
+
+	Person testInsertPerson();
+
+	void cleanDatabase();
+}

src/test/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/dao/TestDatabaseHelperImpl.java

@@ -2,109 +2,56 @@ package de.kreth.vaadin.clubhelper.vaadinclubhelper.dao;
 
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import java.sql.Connection;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
 import java.sql.ResultSet;
-import java.sql.SQLException;
 import java.sql.Statement;
 import java.time.LocalDate;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;
 
+import javax.persistence.EntityManager;
 import javax.persistence.EntityTransaction;
+import javax.persistence.Query;
 
+import org.apache.commons.io.IOUtils;
 import org.hibernate.Session;
-import org.hibernate.SessionFactory;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.BeforeEach;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
 
-import de.kreth.vaadin.clubhelper.HibernateHolder;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubEvent;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubEventBuilder;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubeventHasPerson;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Person;
 
-public abstract class AbstractDatabaseTest {
+@Component
+public final class TestDatabaseHelperImpl implements TestDatabaseHelper {
 
 	private static final AtomicInteger eventIdSequence = new AtomicInteger();
 
-	protected static SessionFactory sessionFactory;
-	protected Session session;
+	private final String truncateString = createTruncateString();
 
-	@BeforeAll
-	public static void setUpDatabase() throws Exception {
-		sessionFactory = HibernateHolder.sessionFactory();
-	}
-
-	public enum DB_TYPE {
-		MYSQL("SET @@foreign_key_checks = 0", "SET @@foreign_key_checks = 1"),
-		H2("SET REFERENTIAL_INTEGRITY FALSE", "SET REFERENTIAL_INTEGRITY TRUE");
-
-		private DB_TYPE(String disableReferentialIntegrety, String enableReferentialIntegrety) {
-			this.disableReferentialIntegrety = disableReferentialIntegrety;
-			this.enableReferentialIntegrety = enableReferentialIntegrety;
-		}
-
-		final String disableReferentialIntegrety;
-		final String enableReferentialIntegrety;
-	}
-
-	@AfterEach
-	public void cleanH2Database() {
-		if (session.getTransaction().isActive()) {
-			session.flush();
-		}
-
-		session.doWork(conn -> {
-			AbstractDatabaseTest.cleanDatabase(conn, DB_TYPE.H2);
-		});
-
-	}
-
-	@BeforeEach
-	void createSession() {
-		if (session != null) {
-			session.close();
-		}
-		session = sessionFactory.openSession();
-	}
-
-	public static void cleanDatabase(Connection connection, DB_TYPE type) throws SQLException {
-
-		String TABLE_NAME = "TABLE_NAME";
-		String[] TABLE_TYPES = { "TABLE" };
-		Set<String> tableNames = new HashSet<>();
-
-		try (ResultSet tables = connection.getMetaData().getTables(null, null, null, TABLE_TYPES)) {
-			while (tables.next()) {
-				tableNames.add(tables.getString(TABLE_NAME));
-			}
-		}
+	@Autowired
+	protected EntityManager entityManager;
 
-		try (Statement stm = connection.createStatement()) {
-			stm.execute(type.disableReferentialIntegrety);
+	private String createTruncateString() {
 		try {
-				for (String tableName : tableNames) {
-					try {
-						stm.executeUpdate("TRUNCATE TABLE " + tableName);
-					} catch (SQLException e) {
+			InputStream resource = getClass().getResourceAsStream("/truncateTables.sql");
+			return IOUtils.toString(resource, StandardCharsets.UTF_8);
+		} catch (IOException e) {
 			throw new RuntimeException(e);
 		}
 	}
-			} finally {
-				stm.execute(type.enableReferentialIntegrety);
-			}
-		}
 
-		if (connection.getAutoCommit() == false) {
-			connection.commit();
-		}
+	@Override
+	public void cleanDatabase() {
+		Query truncateQuery = entityManager.createNativeQuery(truncateString);
+		transactional(() -> truncateQuery.executeUpdate());
 	}
 
 	/**
@@ -112,12 +59,15 @@ public abstract class AbstractDatabaseTest {
 	 * 
 	 * @param r
 	 */
-	protected void transactional(Runnable r) {
+	@Override
+	public void transactional(Runnable r) {
 		transactional(session -> r.run());
 	}
 
-	protected void transactional(Consumer<Session> r) {
+	@Override
+	public void transactional(Consumer<Session> r) {
 
+		Session session = (Session) entityManager;
 		EntityTransaction tx = session.getTransaction();
 		tx.begin();
 		try {
@@ -129,23 +79,25 @@ public abstract class AbstractDatabaseTest {
 		}
 	}
 
+	@Override
 	public Person testInsertPerson() {
 		Person p = new Person();
 		p.setPrename("prename");
 		p.setSurname("surname");
 		p.setBirth(LocalDate.now());
 
-		transactional(() -> session.save(p));
+		transactional(() -> entityManager.persist(p));
 		return p;
 	}
 
+	@Override
 	public List<Person> insertPersons(int count) {
 
 		final List<Person> inserted = createPersons(count);
 
 		transactional(() -> {
 			for (Person p : inserted) {
-				session.save(p);
+				entityManager.persist(p);
 			}
 		});
 		for (Person p : inserted) {
@@ -154,14 +106,14 @@ public abstract class AbstractDatabaseTest {
 		return inserted;
 	}
 
-	public static List<Person> createPersons(int count) {
+	@Override
+	public List<Person> createPersons(int count) {
 
 		final List<Person> inserted = new ArrayList<>();
 
 		for (int i = 0; i < count; i++) {
 
 			Person p = new Person();
-			p.setId(i + 1);
 			p.setPrename("prename_" + i);
 			p.setSurname("surname_" + i);
 			p.setBirth(LocalDate.now());
@@ -170,7 +122,8 @@ public abstract class AbstractDatabaseTest {
 		return inserted;
 	}
 
-	public static ClubEvent creteEvent() {
+	@Override
+	public ClubEvent creteEvent() {
 		ClubEvent ev = ClubEventBuilder.builder().withId("id_" + eventIdSequence.getAndIncrement()).withAllDay(true)
 				.withCaption("caption").withDescription("description")
 				.withStart(ZonedDateTime.of(2018, 8, 13, 0, 0, 0, 0, ZoneId.systemDefault()))
@@ -179,8 +132,10 @@ public abstract class AbstractDatabaseTest {
 		return ev;
 	}
 
+	@Override
 	public List<ClubeventHasPerson> loadEventPersons() {
 
+		Session session = (Session) entityManager;
 		return session.doReturningWork(conn -> {
 
 			List<ClubeventHasPerson> link = new ArrayList<>();
@@ -201,4 +156,9 @@ public abstract class AbstractDatabaseTest {
 
 	}
 
+	@Override
+	public List<ClubEvent> allClubEvent() {
+		return entityManager.createNamedQuery("ClubEvent.findAll", ClubEvent.class).getResultList();
+	}
+
 }

src/test/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/ui/components/PersonFilterTest.java

@@ -10,26 +10,38 @@ import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ContextConfiguration;
 
-import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.AbstractDatabaseTest;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.PersonDao;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.TestDatabaseHelper;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.GroupDef;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Person;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.ui.tests.TestConfiguration;
 
+@SpringBootTest
+@ContextConfiguration(classes = TestConfiguration.class)
 class PersonFilterTest {
 
 	private PersonFilter filter;
 	private List<Person> persons;
-	private final List<GroupDef> groups;
+	private final List<GroupDef> groups = setupData();
+
+	@Autowired
+	TestDatabaseHelper testDatabaseHelper;
+
 	@Mock
 	private PersonDao dao;
 
-	public PersonFilterTest() {
+	static List<GroupDef> setupData() {
+
 		GroupDef adminGroup = new GroupDef();
 		adminGroup.setId(1);
 		adminGroup.setName("ADMIN");
@@ -46,8 +58,7 @@ class PersonFilterTest {
 		judgesGroup.setName("Kampfrichter");
 		judgesGroup.setId(4);
 
-		groups = Collections
-				.unmodifiableList(Arrays.asList(adminGroup, competitorGroup, participantGroup, judgesGroup));
+		return Collections.unmodifiableList(Arrays.asList(adminGroup, competitorGroup, participantGroup, judgesGroup));
 
 	}
 
@@ -55,7 +66,9 @@ class PersonFilterTest {
 	void setUp() throws Exception {
 		MockitoAnnotations.initMocks(this);
 		filter = new PersonFilter(dao);
-		persons = Collections.unmodifiableList(AbstractDatabaseTest.createPersons(5));
+		persons = Collections.unmodifiableList(testDatabaseHelper.createPersons(5));
+		AtomicInteger id = new AtomicInteger(0);
+		persons.forEach(p -> p.setId(id.incrementAndGet()));
 		assertEquals(5, persons.size());
 
 		when(dao.listAll()).thenReturn(persons);

src/test/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/ui/tests/TestConfiguration.java

@@ -7,31 +7,25 @@ import org.springframework.boot.SpringBootConfiguration;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
-import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
 
 import de.kreth.vaadin.clubhelper.HibernateHolder;
 
-//@Configuration
 @SpringBootConfiguration
 @ComponentScan(basePackages = { "de.kreth" })
 @EnableAutoConfiguration
 public class TestConfiguration {
 
+	static {
+		System.setProperty("spring.config.location", "classpath:test.properties");
+		System.setProperty("spring.config.name", "test");
+	}
+
 	private SessionFactory sessionFactory;
 
 	public TestConfiguration() {
 		sessionFactory = HibernateHolder.sessionFactory();
 	}
 
-	@Bean
-	public LocalSessionFactoryBean sessionFactory() throws Exception {
-
-		LocalSessionFactoryBean sessionFactoryBean = new LocalSessionFactoryBean();
-		sessionFactoryBean.setHibernateProperties(HibernateHolder.getProperties());
-
-		return sessionFactoryBean;
-	}
-
 	@Bean
 	public EntityManager entityManager() {
 		return sessionFactory.openSession();

src/test/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/ui/tests/VaadinClubhelperApplicationTests.java

@@ -20,7 +20,6 @@ import javax.persistence.EntityTransaction;
 import javax.persistence.TypedQuery;
 
 import org.hamcrest.Matchers;
-import org.hibernate.Session;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
@@ -36,8 +35,9 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.web.server.LocalServerPort;
+import org.springframework.test.context.TestPropertySource;
 
-import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.AbstractDatabaseTest;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.TestDatabaseHelper;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubEvent;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubEventBuilder;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.GroupDef;
@@ -46,6 +46,7 @@ import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Person;
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
 @AutoConfigureWebTestClient
 @Disabled
+@TestPropertySource(locations = "classpath:test.properties")
 public class VaadinClubhelperApplicationTests {
 
 	private static ChromeOptions options;
@@ -58,6 +59,9 @@ public class VaadinClubhelperApplicationTests {
 	@Autowired
 	EntityManager entityManager;
 
+	@Autowired
+	TestDatabaseHelper testDatabaseHelper;
+
 	private WebDriver driver;
 	private ZonedDateTime now;
 	private WebDriverWait driverWait;
@@ -166,11 +170,7 @@ public class VaadinClubhelperApplicationTests {
 		if (driver != null) {
 			driver.close();
 		}
-		org.hibernate.Session session = (Session) entityManager;
-
-		session.doWork(connection -> {
-			AbstractDatabaseTest.cleanDatabase(connection, AbstractDatabaseTest.DB_TYPE.H2);
-		});
+		testDatabaseHelper.cleanDatabase();
 	}
 
 	@Test

src/test/resources/application.properties

@@ -0,0 +1,8 @@
+spring.datasource.driver-class-name=org.h2.Driver
+spring.datasource.url=jdbc:h2:mem:db;DB_CLOSE_DELAY=-1
+spring.datasource.username=sa
+spring.datasource.password=sa
+
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
+spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy
+spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl