updated junit and switched tests to use spring transaction.

.classpath

@@ -32,7 +32,6 @@
 	</classpathentry>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11">
 		<attributes>
-			<attribute name="module" value="true"/>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>

pom.xml

@@ -1,5 +1,7 @@
 <?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">
+<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>de.kreth.vaadin.clubhelper</groupId>
@@ -263,6 +265,13 @@
 				<type>pom</type>
 				<scope>import</scope>
 			</dependency>
+			<dependency>
+				<groupId>org.junit</groupId>
+				<artifactId>junit-bom</artifactId>
+				<version>5.5.0-M1</version>
+				<type>pom</type>
+				<scope>import</scope>
+			</dependency>
 		</dependencies>
 	</dependencyManagement>
 
@@ -359,5 +368,5 @@
 		<url>https://github.com/markuskreth/vaadin-clubhelper.git</url>
 		<connection>scm:git:git@github.com:markuskreth/vaadin-clubhelper.git</connection>
 		<developerConnection>scm:git:git@github.com:markuskreth/vaadin-clubhelper.git</developerConnection>
-  </scm>
+	</scm>
 </project>

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

@@ -20,7 +20,8 @@ public abstract class AbstractDaoImpl<T extends EntityAccessor> implements IDao<
 	protected final Logger log = LoggerFactory.getLogger(getClass());
 
 	@Autowired
-	protected EntityManager entityManager;
+	protected transient EntityManager entityManager;
+
 	private final Class<T> entityClass;
 
 	public AbstractDaoImpl(Class<T> entityClass) {
@@ -35,7 +36,8 @@ public abstract class AbstractDaoImpl<T extends EntityAccessor> implements IDao<
 		obj.setChanged(now);
 		if (entityManager.contains(obj) || obj.hasValidId()) {
 			entityManager.merge(obj);
-		} else {
+		}
+		else {
 			obj.setCreated(now);
 			entityManager.persist(obj);
 		}

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

@@ -1,5 +1,6 @@
 package de.kreth.vaadin.clubhelper.vaadinclubhelper.business;
 
+import static de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.TestDatabaseHelper.afterCommit;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 
@@ -11,15 +12,13 @@ import java.util.List;
 import javax.persistence.EntityManager;
 import javax.persistence.TypedQuery;
 
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.springframework.transaction.annotation.Transactional;
 
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.ClubhelperException;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.TestDatabaseHelper;
@@ -48,77 +47,85 @@ class EventBusinessSpringTest {
 
 	private TypedQuery<ClubeventHasPerson> all;
 
-	@BeforeEach
 	void setUp() throws Exception {
-		testDatabaseHelper.cleanDatabase();
 		insertTestData();
 		eventBusiness.setSelected(event);
 
 		all = entityManager.createQuery("from ClubeventHasPerson", ClubeventHasPerson.class);
 	}
 
-	@AfterEach
-	void shutdown() {
-		entityManager.clear();
-		testDatabaseHelper.cleanDatabase();
-	}
-
 	private void insertTestData() {
 		persons = new ArrayList<>();
-		testDatabaseHelper.transactional(() -> {
+		for (int i = 0; i < 3; i++) {
-			for (int i = 0; i < 3; i++) {
+
-
+			Person p = new Person();
-				Person p = new Person();
+			p.setPrename("prename_" + i);
-				p.setPrename("prename_" + i);
+			p.setSurname("surname_" + i);
-				p.setSurname("surname_" + i);
+			p.setBirth(LocalDate.now());
-				p.setBirth(LocalDate.now());
+			entityManager.persist(p);
-				entityManager.persist(p);
+			persons.add(p);
-				persons.add(p);
+		}
-			}
+		event = testDatabaseHelper.creteEvent();
-			event = testDatabaseHelper.creteEvent();
+		assertNull(event.getPersons());
-			assertNull(event.getPersons());
+		entityManager.persist(event);
-			entityManager.persist(event);
-		});
 	}
 
 	@Test
-	void testDataCorrectlyCreated() {
+	@Transactional
+	void testDataCorrectlyCreated() throws Exception {
+
+		setUp();
 
-		assertEquals(0, all.getResultList().size());
+		afterCommit(() -> {
 
-		List<Person> stored = entityManager.createNamedQuery(Person.QUERY_FINDALL, Person.class).getResultList();
+			assertEquals(0, all.getResultList().size());
-		assertEquals(3, stored.size());
 
-		List<ClubEvent> events = eventBusiness.loadEvents();
+			List<Person> stored = entityManager.createNamedQuery(Person.QUERY_FINDALL, Person.class).getResultList();
-		assertEquals(1, events.size());
+			assertEquals(3, stored.size());
+
+			List<ClubEvent> events = eventBusiness.loadEvents();
+			assertEquals(1, events.size());
+		});
 
 	}
 
 	@Test
-	@Disabled
+	@Transactional
-	void testAddPersonsToEvent() {
+	void testAddPersonsToEvent() throws Exception {
-		assertEquals(0, all.getResultList().size());
+		setUp();
-		try {
-			transactional(() -> eventBusiness.changePersons(new HashSet<>(persons.subList(0, 1))));
-			transactional(() -> eventBusiness.changePersons(new HashSet<>(persons.subList(0, 2))));
-		}
-		catch (Exception e) {
 
-		}
+		afterCommit(() -> {
+			assertEquals(0, all.getResultList().size());
+		});
 
-		List<ClubeventHasPerson> result = all.getResultList();
+		afterCommit(() -> {
-		assertEquals(2, result.size());
+			try {
-	}
+				eventBusiness.changePersons(new HashSet<>(persons.subList(0, 1)));
+			}
+			catch (ClubhelperException e) {
+				throw new RuntimeException(e);
+			}
+		});
 
-	private void transactional(ThrowingRunnable<ClubhelperException> object) {
+		afterCommit(() -> {
-		testDatabaseHelper.transactional(() -> {
+			List<ClubeventHasPerson> result = all.getResultList();
+			assertEquals(1, result.size());
+		});
+
+		afterCommit(() -> {
 			try {
-				object.run();
+				eventBusiness.changePersons(new HashSet<>(persons.subList(0, 2)));
 			}
 			catch (ClubhelperException e) {
 				throw new RuntimeException(e);
 			}
 		});
+
+		afterCommit(() -> {
+			List<ClubeventHasPerson> result = all.getResultList();
+			assertEquals(2, result.size());
+		});
+
 	}
 
 }

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

@@ -1,5 +1,6 @@
 package de.kreth.vaadin.clubhelper.vaadinclubhelper.dao;
 
+import static de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.TestDatabaseHelper.afterCommit;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -11,12 +12,12 @@ import java.util.Set;
 
 import javax.persistence.EntityManager;
 
-import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Tag;
 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 org.springframework.transaction.annotation.Transactional;
 
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubEvent;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubeventHasPerson;
@@ -35,42 +36,43 @@ public class ClubEventDataTest {
 	@Autowired
 	TestDatabaseHelper testDatabaseHelper;
 
-	@AfterEach
-	public void cleanDatabase() {
-		testDatabaseHelper.cleanDatabase();
-	}
-
 	@Test
+	@Transactional
 	public void testEventAddon() {
 
 		ClubEvent ev = testDatabaseHelper.creteEvent();
 		ev.setType(Type.EINZEL);
 
-		testDatabaseHelper.transactional(() -> {
+		entityManager.persist(ev);
-			entityManager.persist(ev);
+		afterCommit(() -> {
-//			entityManager.persist(ev.getCompetitionType());
+			List<ClubEvent> allClubEvent = testDatabaseHelper.allClubEvent();
+			assertEquals(1, allClubEvent.size());
+			assertEquals(Type.EINZEL, allClubEvent.get(0).getType());
 		});
-		List<ClubEvent> allClubEvent = testDatabaseHelper.allClubEvent();
-		assertEquals(1, allClubEvent.size());
-		assertEquals(Type.EINZEL, allClubEvent.get(0).getType());
 
 		ev.setType(Type.DOPPELMINI);
-		testDatabaseHelper.transactional(() -> entityManager.merge(ev));
+		entityManager.merge(ev);
-		allClubEvent = testDatabaseHelper.allClubEvent();
+
-		assertEquals(1, allClubEvent.size());
+		afterCommit(() -> {
-		assertEquals(Type.DOPPELMINI, allClubEvent.get(0).getType());
+			List<ClubEvent> allClubEvent = testDatabaseHelper.allClubEvent();
+			assertEquals(1, allClubEvent.size());
+			assertEquals(Type.DOPPELMINI, allClubEvent.get(0).getType());
+		});
 	}
 
 	@Test
+	@Transactional
 	public void testSaveAndSelectEvent() {
 		ClubEvent ev = testDatabaseHelper.creteEvent();
-
+		entityManager.persist(ev);
-		testDatabaseHelper.transactional(() -> entityManager.persist(ev));
+		afterCommit(() -> {
-		List<ClubEvent> result = testDatabaseHelper.allClubEvent();
+			List<ClubEvent> result = testDatabaseHelper.allClubEvent();
-		assertEquals(1, result.size());
+			assertEquals(1, result.size());
+		});
 	}
 
 	@Test
+	@Transactional
 	public void testEventWithPerson() {
 
 		ClubEvent ev = testDatabaseHelper.creteEvent();
@@ -82,22 +84,23 @@ public class ClubEventDataTest {
 			ev.setPersons(persons);
 		}
 		persons.add(person);
+		entityManager.persist(ev);
 
-		testDatabaseHelper.transactional(() -> entityManager.persist(ev));
+		afterCommit(() -> {
-
+			List<ClubeventHasPerson> loadEventPersons = testDatabaseHelper.loadEventPersons();
-		List<ClubeventHasPerson> loadEventPersons = testDatabaseHelper.loadEventPersons();
+			assertFalse(loadEventPersons.isEmpty());
-		assertFalse(loadEventPersons.isEmpty());
+			ClubeventHasPerson link = loadEventPersons.get(0);
-		ClubeventHasPerson link = loadEventPersons.get(0);
+			assertEquals(person.getId(), link.getPersonId());
-		assertEquals(person.getId(), link.getPersonId());
+			assertEquals(ev.getId(), link.getClubEventId());
-		assertEquals(ev.getId(), link.getClubEventId());
 
+		});
 	}
 
 	@Test
+	@Transactional
 	public void changeEventsPersons() {
 		ClubEvent ev = testDatabaseHelper.creteEvent();
-
+		entityManager.persist(ev);
-		testDatabaseHelper.transactional(() -> entityManager.persist(ev));
 
 		Person person = testDatabaseHelper.testInsertPerson();
 
@@ -106,7 +109,7 @@ public class ClubEventDataTest {
 		person2.setSurname(person.getSurname() + "_2");
 		person2.setBirth(LocalDate.now());
 
-		testDatabaseHelper.transactional(() -> entityManager.persist(person2));
+		entityManager.persist(person2);
 
 		ClubEvent loaded = entityManager.find(ClubEvent.class, ev.getId());
 		assertNotNull(loaded);
@@ -115,41 +118,47 @@ public class ClubEventDataTest {
 		}
 
 		loaded.add(person);
-		testDatabaseHelper.transactional(() -> entityManager.merge(ev));
+		entityManager.merge(ev);
 
 		loaded.add(person2);
-		testDatabaseHelper.transactional(() -> entityManager.merge(ev));
+		entityManager.merge(ev);
 
-		List<ClubeventHasPerson> entries = testDatabaseHelper.loadEventPersons();
+		afterCommit(() -> {
-		assertEquals(2, entries.size());
+			List<ClubeventHasPerson> entries = testDatabaseHelper.loadEventPersons();
+			assertEquals(2, entries.size());
+		});
 	}
 
 	@Test
+	@Transactional
 	public void testChangeEventParticipantsRapidly() {
 
 		final ClubEvent created = testDatabaseHelper.creteEvent();
-		testDatabaseHelper.transactional(() -> {
+		entityManager.persist(created);
-			entityManager.persist(created);
-		});
 
-		final ClubEvent ev = entityManager.find(ClubEvent.class, created.getId());
+		afterCommit(() -> {
-		List<Person> persons = testDatabaseHelper.insertPersons(6);
+			final ClubEvent ev = entityManager.find(ClubEvent.class, created.getId());
-		for (Person p : persons) {
+			List<Person> persons = testDatabaseHelper.insertPersons(6);
-			ev.add(p);
+			for (Person p : persons) {
-			testDatabaseHelper.transactional(() -> entityManager.merge(ev));
+				ev.add(p);
-		}
+				entityManager.merge(ev);
-		ev.remove(persons.get(2));
+			}
-		testDatabaseHelper.transactional(() -> entityManager.merge(ev));
+			ev.remove(persons.get(2));
+			entityManager.merge(ev);
 
-		ev.remove(persons.get(4));
+			ev.remove(persons.get(4));
-		testDatabaseHelper.transactional(() -> entityManager.merge(ev));
+			entityManager.merge(ev);
 
-		ev.getPersons().add(persons.get(2));
+			ev.getPersons().add(persons.get(2));
-		ev.getPersons().add(persons.get(4));
+			ev.getPersons().add(persons.get(4));
-		testDatabaseHelper.transactional(() -> entityManager.merge(ev));
+			entityManager.merge(ev);
 
-		List<ClubeventHasPerson> result = testDatabaseHelper.loadEventPersons();
+		});
-		assertEquals(6, result.size());
+		afterCommit(() -> {
+
+			List<ClubeventHasPerson> result = testDatabaseHelper.loadEventPersons();
+			assertEquals(6, result.size());
+		});
 	}
 
 }

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

@@ -1,10 +1,7 @@
 package de.kreth.vaadin.clubhelper.vaadinclubhelper.dao;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
 
-import java.io.IOException;
 import java.sql.ResultSet;
 import java.sql.Statement;
 import java.util.List;
@@ -13,22 +10,22 @@ import javax.persistence.EntityManager;
 
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
-import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.annotation.Rollback;
 import org.springframework.test.context.ContextConfiguration;
+import org.springframework.transaction.annotation.Transactional;
 
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Person;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.ui.tests.TestConfiguration;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.ui.tests.TestPersonGenerator;
 
 @SpringBootTest
 @ContextConfiguration(classes = TestConfiguration.class)
 @Tag("spring")
-@Disabled
 public class PersonDaoRelativeTest {
 
 	@Autowired
@@ -37,51 +34,56 @@ public class PersonDaoRelativeTest {
 	@Autowired
 	private EntityManager entityManager;
 
-	@Autowired
-	private TestDatabaseHelper testDatabaseHelper;
-
 	@Autowired
 	private SessionFactory sessionFactory;
 
-	private Person person1;
+	private List<Person> persons;
-
-	private Person person2;
 
 	@BeforeEach
+	@Transactional
+	@Rollback(false)
 	public void setUp() throws Exception {
-//		testDatabaseHelper.cleanDatabase();
-//		List<Person> persons = TestPersonGenerator.generatePersonen(2);
-//		person1 = persons.get(0);
-//		person2 = persons.get(1);
 
-		List<Person> resultList = entityManager.createNamedQuery(Person.QUERY_FINDALL, Person.class).getResultList();
+		persons = TestPersonGenerator.generatePersonen(2);
-		assertFalse(resultList.isEmpty());
+		for (Person p : persons) {
-	}
+			p.setId(0);
+		}
 
-	@AfterEach
-	public void clearDatabase() throws IOException {
-//		testDatabaseHelper.cleanDatabase();
 	}
 
 	@Test
+	@Transactional
 	void testLoadPersonById() {
-		person1 = entityManager.find(Person.class, Integer.valueOf(1));
+		for (Person p : persons) {
-		assertNotNull(person1);
+			personDao.save(p);
-		assertEquals(1, person1.getId());
+		}
+		TestDatabaseHelper.afterCommit(() -> {
+			Person person1 = entityManager.find(Person.class, 1);
+			assertNotNull(person1);
+		});
 	}
 
 	@Test
+	@Transactional
 	void testStorePersonChildRelationship() {
-		Session session = sessionFactory.openSession();
+		for (Person p : persons) {
-		session.doWork(conn -> {
+			personDao.save(p);
-			try (Statement stm = conn.createStatement()) {
+		}
-				ResultSet rs = stm.executeQuery(
+		TestDatabaseHelper.afterCommit(() -> {
-						"SELECT id, person1, person2, TO_PERSON1_RELATION, TO_PERSON2_RELATION, changed, created, deleted FROM relative where person1=1 OR person2=1 and deleted is null");
+			Session session = sessionFactory.openSession();
-				while (rs.next()) {
+			session.doWork(conn -> {
-					System.out.println("id=" + rs.getInt("id") + ", person1=" + rs.getInt("person1") + ", person2="
+				try (Statement stm = conn.createStatement()) {
-							+ rs.getInt("person2") + ", TO_PERSON1_RELATION=" + rs.getString("TO_PERSON1_RELATION"));
+					ResultSet rs = stm.executeQuery(
+							"SELECT id, person1, person2, TO_PERSON1_RELATION, TO_PERSON2_RELATION, changed, created, deleted FROM relative where person1=1 OR person2=1 and deleted is null");
+					while (rs.next()) {
+						System.out.println(
+								"id=" + rs.getInt("id") + ", person1=" + rs.getInt("person1") + ", person2="
+										+ rs.getInt("person2") + ", TO_PERSON1_RELATION="
+										+ rs.getString("TO_PERSON1_RELATION"));
+					}
 				}
-			}
+			});
 		});
 	}
+
 }

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

@@ -1,22 +1,21 @@
 package de.kreth.vaadin.clubhelper.vaadinclubhelper.dao;
 
+import static de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.TestDatabaseHelper.afterCommit;
 import static org.junit.Assert.assertTrue;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
 
-import java.io.IOException;
 import java.time.LocalDate;
 import java.util.List;
 
 import javax.persistence.EntityManager;
 
-import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Tag;
 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 org.springframework.transaction.annotation.Transactional;
 
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Gender;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.Person;
@@ -33,14 +32,10 @@ public class PersonDaoTest {
 	@Autowired
 	private EntityManager entityManager;
 
-	@Autowired
-	private TestDatabaseHelper testDatabaseHelper;
-
 	private Person person;
 
 	@BeforeEach
 	public void setUp() throws Exception {
-		testDatabaseHelper.cleanDatabase();
 		person = new Person();
 		person.setPrename("prename");
 		person.setSurname("surname");
@@ -50,54 +45,58 @@ public class PersonDaoTest {
 		assertTrue(entityManager.createNamedQuery(Person.QUERY_FINDALL, Person.class).getResultList().isEmpty());
 	}
 
-	@AfterEach
-	public void clearDatabase() throws IOException {
-		testDatabaseHelper.cleanDatabase();
-	}
-
 	@Test
+	@Transactional
 	public void testSave() {
-		testDatabaseHelper.transactional(() -> personDao.save(person));
+		personDao.save(person);
-
+		afterCommit(() -> {
-		List<Person> stored = entityManager.createNamedQuery(Person.QUERY_FINDALL, Person.class).getResultList();
+			List<Person> stored = entityManager.createNamedQuery(Person.QUERY_FINDALL, Person.class).getResultList();
-		assertEquals(1, stored.size());
+			assertEquals(1, stored.size());
-		assertEquals(person, stored.get(0));
+			assertEquals(person, stored.get(0));
-		assertEquals(person, personDao.get(person.getId()));
+			assertEquals(person, personDao.get(person.getId()));
+		});
 
 	}
 
 	@Test
+	@Transactional
 	public void testUpdate() {
 
-		testDatabaseHelper.transactional(() -> personDao.save(person));
+		personDao.save(person);
-		person.setSurname("surname2");
+		afterCommit(() -> {
-		person.setPrename("prename2");
+
+			person.setSurname("surname2");
+			person.setPrename("prename2");
 
-		testDatabaseHelper.transactional(() -> personDao.save(person));
+			personDao.save(person);
 
-		List<Person> stored = entityManager.createNamedQuery(Person.QUERY_FINDALL, Person.class).getResultList();
+		});
-		assertEquals(1, stored.size());
+		afterCommit(() -> {
-		assertEquals(person, stored.get(0));
+			List<Person> stored = entityManager.createNamedQuery(Person.QUERY_FINDALL, Person.class).getResultList();
+			assertEquals(1, stored.size());
+			assertEquals(person, stored.get(0));
+		});
 	}
 
 	@Test
+	@Transactional
 	public void testListAll() {
-		testDatabaseHelper.transactional(() -> personDao.save(person));
+
+		personDao.save(person);
 
 		person = new Person();
 		person.setSurname("surname2");
 		person.setPrename("prename2");
 		person.setBirth(LocalDate.of(2018, 11, 8));
 		person.setPassword("password");
+		personDao.save(person);
 
-		testDatabaseHelper.transactional(() -> personDao.save(person));
+		afterCommit(() -> {
-		List<Person> stored = personDao.listAll();
-		assertEquals(2, stored.size());
 
-	}
+			List<Person> stored = personDao.listAll();
+			assertEquals(2, stored.size());
+		});
 
-	@Test
-	public void testPersonGroup() {
-		assertNotNull(new GroupDaoImpl());
 	}
+
 }

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

@@ -1,9 +1,9 @@
 package de.kreth.vaadin.clubhelper.vaadinclubhelper.dao;
 
 import java.util.List;
-import java.util.function.Consumer;
 
-import org.hibernate.Session;
+import org.springframework.transaction.support.TransactionSynchronizationAdapter;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubEvent;
 import de.kreth.vaadin.clubhelper.vaadinclubhelper.data.ClubeventHasPerson;
@@ -11,15 +11,6 @@ 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);
@@ -32,5 +23,18 @@ public interface TestDatabaseHelper {
 
 	Person testInsertPerson();
 
-	void cleanDatabase();
+	public static void afterCommit(final Runnable r) {
+
+		TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
+			@Override
+			public void afterCommit() {
+				r.run();
+			}
+		});
+	}
+
+	public static void waitForCommit() {
+		afterCommit(() -> {
+		});
+	}
 }

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

@@ -14,10 +14,8 @@ import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.Consumer;
 
 import javax.persistence.EntityManager;
-import javax.persistence.EntityTransaction;
 
 import org.hibernate.Session;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -36,28 +34,6 @@ public class TestDatabaseHelperImpl implements TestDatabaseHelper {
 	@Autowired
 	protected EntityManager entityManager;
 
-	@Override
-	public void cleanDatabase() {
-
-		Session session = (Session) entityManager;
-		session.doWork(conn -> {
-
-			List<String> tableNames = loadTables(conn);
-			try (Statement stm = conn.createStatement()) {
-
-				stm.addBatch("SET FOREIGN_KEY_CHECKS=0");
-				for (String table : tableNames) {
-					stm.addBatch("TRUNCATE TABLE " + table);
-				}
-				stm.addBatch("SET FOREIGN_KEY_CHECKS=1");
-				stm.executeBatch();
-			}
-			if (conn.getAutoCommit() == false) {
-				conn.commit();
-			}
-		});
-	}
-
 	public List<String> loadTables(Connection conn) throws SQLException {
 		List<String> tableNames = new ArrayList<>();
 
@@ -71,30 +47,24 @@ public class TestDatabaseHelperImpl implements TestDatabaseHelper {
 		return tableNames;
 	}
 
-	/**
+//	private void transactional(Runnable r) {
-	 * executes the given runnable within a jpa Transaction.
+//		transactional(session -> r.run());
-	 * 
+//	}
-	 * @param r
+//
-	 */
+//	private void transactional(Consumer<Session> r) {
-	@Override
+//
-	public void transactional(Runnable r) {
+//		Session session = (Session) entityManager;
-		transactional(session -> r.run());
+//		EntityTransaction tx = session.getTransaction();
-	}
+//		tx.begin();
-
+//		try {
-	@Override
+//			r.accept(session);
-	public void transactional(Consumer<Session> r) {
+//			tx.commit();
-
+//		}
-		Session session = (Session) entityManager;
+//		catch (Exception e) {
-		EntityTransaction tx = session.getTransaction();
+//			tx.rollback();
-		tx.begin();
+//			throw e;
-		try {
+//		}
-			r.accept(session);
+//	}
-			tx.commit();
-		} catch (Exception e) {
-			tx.rollback();
-			throw e;
-		}
-	}
 
 	@Override
 	public Person testInsertPerson() {
@@ -103,7 +73,7 @@ public class TestDatabaseHelperImpl implements TestDatabaseHelper {
 		p.setSurname("surname");
 		p.setBirth(LocalDate.now());
 
-		transactional(() -> entityManager.persist(p));
+		entityManager.persist(p);
 		return p;
 	}
 
@@ -112,11 +82,9 @@ public class TestDatabaseHelperImpl implements TestDatabaseHelper {
 
 		final List<Person> inserted = createPersons(count);
 
-		transactional(() -> {
+		for (Person p : inserted) {
-			for (Person p : inserted) {
+			entityManager.persist(p);
-				entityManager.persist(p);
+		}
-			}
-		});
 		for (Person p : inserted) {
 			assertTrue(p.getId() > 0, "not saved: " + p);
 		}

src/test/java/de/kreth/vaadin/clubhelper/vaadinclubhelper/ui/SmokeUITest.java

@@ -0,0 +1,132 @@
+package de.kreth.vaadin.clubhelper.vaadinclubhelper.ui;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.runner.RunWith;
+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.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.test.web.reactive.server.EntityExchangeResult;
+import org.springframework.test.web.reactive.server.WebTestClient;
+import org.springframework.test.web.reactive.server.WebTestClient.BodyContentSpec;
+import org.springframework.test.web.reactive.server.WebTestClient.ResponseSpec;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.vaadin.server.VaadinSession;
+
+import de.kreth.googleconnectors.calendar.CalendarAdapter;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.business.EventBusiness;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.GroupDao;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.PersonDao;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.dao.PflichtenDao;
+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.security.SecurityVerifier;
+import de.kreth.vaadin.clubhelper.vaadinclubhelper.ui.navigation.ClubhelperNavigation;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT) // , properties =
+																// "spring.main.web-application-type=reactive"
+@AutoConfigureWebTestClient
+@Tag("spring")
+public class SmokeUITest {
+
+	@Autowired
+	WebTestClient webClient;
+
+	@Autowired
+	PersonDao personDao;
+
+	@Autowired
+	GroupDao groupDao;
+
+	@Autowired
+	EventBusiness eventBusiness;
+
+	@Autowired
+	PflichtenDao pflichtenDao;
+
+	@Autowired
+	SecurityVerifier securityGroupVerifier;
+
+	@Autowired
+	CalendarAdapter calendarAdapter;
+
+	@Autowired
+	ClubhelperNavigation clubhelperNavigation;
+
+	@Test
+	public void autowiredComponentsArePresent() {
+		List<Field> autowiredFields = Arrays.asList(getClass().getDeclaredFields()).stream()
+				.filter(f -> f.getAnnotation(Autowired.class) != null)
+				.collect(Collectors.toList());
+
+		for (Field field : autowiredFields) {
+			try {
+				Object object = field.get(this);
+				assertNotNull(object, "Null object in field: " + field);
+			}
+			catch (IllegalArgumentException | IllegalAccessException e) {
+				throw new RuntimeException("Error accessing object in Field " + field, e);
+			}
+		}
+	}
+
+	@Test
+	void databaseIsEmpty() {
+		List<Person> allPersons = personDao.listAll();
+		assertEquals(0, allPersons.size());
+	}
+
+	@Test
+	@Transactional
+	void useDatabase() {
+		GroupDef group = new GroupDef();
+		group.setName("admin");
+
+		this.groupDao.save(group);
+		TestDatabaseHelper.afterCommit(() -> {
+			assertEquals(1, groupDao.listAll().size());
+		});
+	}
+
+	@Test
+	void securityGroupVerifierIsLoggedin() {
+		VaadinSession session = mock(VaadinSession.class);
+		VaadinSession.setCurrent(session);
+		assertFalse(securityGroupVerifier.isLoggedin());
+		Person person = new Person();
+		Set<GroupDef> groups = new HashSet<GroupDef>();
+		groups.add(new GroupDef());
+		person.setGroups(groups);
+		securityGroupVerifier.setLoggedinPerson(person); // must be set and have at least one Group defined.
+		assertTrue(securityGroupVerifier.isLoggedin());
+	}
+
+	@Test
+	void webClientAccess() {
+		ResponseSpec responseSpec = this.webClient.get().uri("/").exchange();
+		responseSpec.expectStatus().isOk();
+		BodyContentSpec body = responseSpec.expectBody();
+		EntityExchangeResult<byte[]> result = body.returnResult();
+		String content = new String(result.getResponseBody());
+		assertFalse(content.isBlank());
+		assertTrue(content.toLowerCase().contains("vaadin"));
+	}
+}

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

@@ -10,7 +10,7 @@ public class TestPersonGenerator {
 
 	public static List<Person> generatePersonen(int count) {
 		List<Person> personen = new ArrayList<>();
-		for (int i = 0; i < count; i++) {
+		for (int i = 1; i <= count; i++) {
 			Person p = new Person();
 			p.setId(i);
 			p.setPrename("prename_" + i);