[Minor] refactored tests for persistence layers to remove duplicate code

pom.xml

@@ -38,6 +38,11 @@
 			<groupId>li.strolch</groupId>
 			<artifactId>li.strolch.runtime</artifactId>
 		</dependency>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<scope>compile</scope>
+		</dependency>
 	</dependencies>
 
 	<build>

src/main/java/li/strolch/testbase/runtime/OrderModelTestRunner.java

@@ -0,0 +1,157 @@
+package li.strolch.testbase.runtime;
+
+import static li.strolch.model.ModelGenerator.BAG_ID;
+import static li.strolch.model.ModelGenerator.PARAM_STRING_ID;
+import static li.strolch.model.ModelGenerator.createOrder;
+import static li.strolch.model.ModelGenerator.createOrders;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import li.strolch.model.Order;
+import li.strolch.model.parameter.Parameter;
+import li.strolch.persistence.api.OrderDao;
+import li.strolch.persistence.api.PersistenceHandler;
+import li.strolch.persistence.api.StrolchTransaction;
+
+@SuppressWarnings("nls")
+public class OrderModelTestRunner {
+
+	private static final String ID = "@testOrder";
+	private static final String NAME = "Test Order";
+	private static final String TYPE = "ToStock";
+
+	private RuntimeMock runtimeMock;
+
+	public OrderModelTestRunner(RuntimeMock runtimeMock) {
+		this.runtimeMock = runtimeMock;
+	}
+
+	protected PersistenceHandler getPersistenceHandler() {
+		return this.runtimeMock.getPersistenceHandler();
+	}
+
+	public void runCreateOrderTest() {
+
+		// create
+		Order newOrder = createOrder("MyTestOrder", "Test Name", "TestType"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			tx.getOrderDao().save(newOrder);
+		}
+	}
+
+	public void runCrudTests() {
+
+		// create
+		Order newOrder = createOrder(ID, NAME, TYPE);
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			tx.getOrderDao().save(newOrder);
+		}
+
+		// read
+		Order readOrder = null;
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			readOrder = tx.getOrderDao().queryBy(TYPE, ID);
+		}
+		assertNotNull("Should read Order with id " + ID, readOrder);
+
+		// update
+		Parameter<String> sParam = readOrder.getParameter(BAG_ID, PARAM_STRING_ID);
+		String newStringValue = "Giddiya!";
+		sParam.setValue(newStringValue);
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			tx.getOrderDao().update(readOrder);
+		}
+
+		// read updated
+		Order updatedOrder = null;
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			updatedOrder = tx.getOrderDao().queryBy(TYPE, ID);
+		}
+		assertNotNull("Should read Order with id " + ID, updatedOrder);
+		assertFalse("Objects can't be the same reference after re-reading!", readOrder == updatedOrder);
+		Parameter<String> updatedParam = readOrder.getParameter(BAG_ID, PARAM_STRING_ID);
+		assertEquals(newStringValue, updatedParam.getValue());
+
+		// delete
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			tx.getOrderDao().remove(readOrder);
+		}
+
+		// fail to re-read
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			Order order = tx.getOrderDao().queryBy(TYPE, ID);
+			assertNull("Should no read Order with id " + ID, order);
+		}
+	}
+
+	public void runBulkOperationTests() {
+
+		List<Order> orders = new ArrayList<>();
+		orders.addAll(createOrders(orders.size(), 5, "@", "My Order ", "MyType1"));
+		orders.addAll(createOrders(orders.size(), 5, "@", "Other Order ", "MyType2"));
+		orders.addAll(createOrders(orders.size(), 5, "@", "Further Order ", "MyType3"));
+
+		Comparator<Order> comparator = new Comparator<Order>() {
+			@Override
+			public int compare(Order o1, Order o2) {
+				return o1.getId().compareTo(o2.getId());
+			}
+		};
+		Collections.sort(orders, comparator);
+
+		try (StrolchTransaction tx = getPersistenceHandler().openTx()) {
+			tx.getOrderDao().removeAll(tx.getOrderDao().queryAll());
+		}
+
+		try (StrolchTransaction tx = getPersistenceHandler().openTx()) {
+			tx.getOrderDao().saveAll(orders);
+		}
+
+		Set<String> expectedTypes = new HashSet<>();
+		expectedTypes.add("MyType1");
+		expectedTypes.add("MyType2");
+		expectedTypes.add("MyType3");
+
+		try (StrolchTransaction tx = getPersistenceHandler().openTx()) {
+			List<Order> allOrders = tx.getOrderDao().queryAll();
+			Collections.sort(allOrders, comparator);
+			assertEquals(orders, allOrders);
+		}
+
+		try (StrolchTransaction tx = getPersistenceHandler().openTx()) {
+			OrderDao orderDao = tx.getOrderDao();
+
+			Set<String> types = orderDao.queryTypes();
+			assertEquals(expectedTypes, types);
+
+			Set<String> keySet = orderDao.queryKeySet();
+			assertEquals(15, keySet.size());
+
+			for (String type : types) {
+				Set<String> idsByType = orderDao.queryKeySet(type);
+				assertEquals(5, idsByType.size());
+
+				List<Order> ordersByType = orderDao.queryAll(type);
+				assertEquals(5, ordersByType.size());
+			}
+		}
+
+		try (StrolchTransaction tx = getPersistenceHandler().openTx()) {
+			Order order = tx.getOrderDao().queryBy("MyType1", "@_00000001");
+			assertNotNull(order);
+			order = tx.getOrderDao().queryBy("MyType2", "@_00000006");
+			assertNotNull(order);
+			order = tx.getOrderDao().queryBy("MyType3", "@_00000011");
+			assertNotNull(order);
+		}
+	}
+}

src/main/java/li/strolch/testbase/runtime/ResourceModelTestRunner.java

@@ -0,0 +1,157 @@
+package li.strolch.testbase.runtime;
+
+import static li.strolch.model.ModelGenerator.BAG_ID;
+import static li.strolch.model.ModelGenerator.PARAM_STRING_ID;
+import static li.strolch.model.ModelGenerator.createResource;
+import static li.strolch.model.ModelGenerator.createResources;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import li.strolch.model.Resource;
+import li.strolch.model.parameter.Parameter;
+import li.strolch.persistence.api.PersistenceHandler;
+import li.strolch.persistence.api.ResourceDao;
+import li.strolch.persistence.api.StrolchTransaction;
+
+@SuppressWarnings("nls")
+public class ResourceModelTestRunner {
+
+	private static final String ID = "@testResource"; //$NON-NLS-1$
+	private static final String NAME = "Test Resource"; //$NON-NLS-1$
+	private static final String TYPE = "Box"; //$NON-NLS-1$
+
+	private RuntimeMock runtimeMock;
+
+	public ResourceModelTestRunner(RuntimeMock runtimeMock) {
+		this.runtimeMock = runtimeMock;
+	}
+
+	protected PersistenceHandler getPersistenceHandler() {
+		return this.runtimeMock.getPersistenceHandler();
+	}
+
+	public void runCreateResourceTest() {
+
+		// create
+		Resource newResource = createResource("MyTestResource", "Test Name", "TestType"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			tx.getResourceDao().save(newResource);
+		}
+	}
+
+	public void runCrudTests() {
+
+		// create
+		Resource newResource = createResource(ID, NAME, TYPE);
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			tx.getResourceDao().save(newResource);
+		}
+
+		// read
+		Resource readResource = null;
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			readResource = tx.getResourceDao().queryBy(TYPE, ID);
+		}
+		assertNotNull("Should read Resource with id " + ID, readResource); //$NON-NLS-1$
+
+		// update
+		Parameter<String> sParam = readResource.getParameter(BAG_ID, PARAM_STRING_ID);
+		String newStringValue = "Giddiya!"; //$NON-NLS-1$
+		sParam.setValue(newStringValue);
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			tx.getResourceDao().update(readResource);
+		}
+
+		// read updated
+		Resource updatedResource = null;
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			updatedResource = tx.getResourceDao().queryBy(TYPE, ID);
+		}
+		assertNotNull("Should read Resource with id " + ID, updatedResource); //$NON-NLS-1$
+		assertFalse("Objects can't be the same reference after re-reading!", readResource == updatedResource); //$NON-NLS-1$
+		Parameter<String> updatedParam = readResource.getParameter(BAG_ID, PARAM_STRING_ID);
+		assertEquals(newStringValue, updatedParam.getValue());
+
+		// delete
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			tx.getResourceDao().remove(readResource);
+		}
+
+		// fail to re-read
+		try (StrolchTransaction tx = getPersistenceHandler().openTx();) {
+			Resource resource = tx.getResourceDao().queryBy(TYPE, ID);
+			assertNull("Should no read Resource with id " + ID, resource); //$NON-NLS-1$
+		}
+	}
+
+	public void runBulkOperationTests() {
+
+		List<Resource> resources = new ArrayList<>();
+		resources.addAll(createResources(resources.size(), 5, "@", "My Resource ", "MyType1"));
+		resources.addAll(createResources(resources.size(), 5, "@", "Other Resource ", "MyType2"));
+		resources.addAll(createResources(resources.size(), 5, "@", "Further Resource ", "MyType3"));
+
+		Comparator<Resource> comparator = new Comparator<Resource>() {
+			@Override
+			public int compare(Resource o1, Resource o2) {
+				return o1.getId().compareTo(o2.getId());
+			}
+		};
+		Collections.sort(resources, comparator);
+
+		try (StrolchTransaction tx = getPersistenceHandler().openTx()) {
+			tx.getResourceDao().removeAll(tx.getResourceDao().queryAll());
+		}
+
+		try (StrolchTransaction tx = getPersistenceHandler().openTx()) {
+			tx.getResourceDao().saveAll(resources);
+		}
+
+		Set<String> expectedTypes = new HashSet<>();
+		expectedTypes.add("MyType1");
+		expectedTypes.add("MyType2");
+		expectedTypes.add("MyType3");
+
+		try (StrolchTransaction tx = getPersistenceHandler().openTx()) {
+			List<Resource> allResources = tx.getResourceDao().queryAll();
+			Collections.sort(allResources, comparator);
+			assertEquals(resources, allResources);
+		}
+
+		try (StrolchTransaction tx = getPersistenceHandler().openTx()) {
+			ResourceDao resourceDao = tx.getResourceDao();
+
+			Set<String> types = resourceDao.queryTypes();
+			assertEquals(expectedTypes, types);
+
+			Set<String> keySet = resourceDao.queryKeySet();
+			assertEquals(15, keySet.size());
+
+			for (String type : types) {
+				Set<String> idsByType = resourceDao.queryKeySet(type);
+				assertEquals(5, idsByType.size());
+
+				List<Resource> resourcesByType = resourceDao.queryAll(type);
+				assertEquals(5, resourcesByType.size());
+			}
+		}
+
+		try (StrolchTransaction tx = getPersistenceHandler().openTx()) {
+			Resource resource = tx.getResourceDao().queryBy("MyType1", "@_00000001");
+			assertNotNull(resource);
+			resource = tx.getResourceDao().queryBy("MyType2", "@_00000006");
+			assertNotNull(resource);
+			resource = tx.getResourceDao().queryBy("MyType3", "@_00000011");
+			assertNotNull(resource);
+		}
+	}
+}

src/main/java/li/strolch/testbase/runtime/RuntimeMock.java

@@ -29,30 +29,31 @@ import org.slf4j.LoggerFactory;
 
 import ch.eitchnet.utils.helper.FileHelper;
 
-public class RuntimeMock {
+public final class RuntimeMock {
 
 	private static final Logger logger = LoggerFactory.getLogger(RuntimeMock.class);
 	private static final String TARGET = "target"; //$NON-NLS-1$
 
-	private static ComponentContainer container;
-	private static StrolchAgent agent;
+	private ComponentContainer container;
+	private StrolchAgent agent;
 
-	/**
-	 * @return the container
-	 */
-	public static ComponentContainer getContainer() {
-		return container;
+	public ComponentContainer getContainer() {
+		return this.container;
 	}
 
-	public static StrolchPrivilegeHandler getPrivilegeHandler() {
-		return container.getComponent(StrolchPrivilegeHandler.class);
+	public StrolchAgent getAgent() {
+		return this.agent;
 	}
 
-	public static PersistenceHandler getPersistenceHandler() {
-		return container.getComponent(PersistenceHandler.class);
+	public StrolchPrivilegeHandler getPrivilegeHandler() {
+		return this.container.getComponent(StrolchPrivilegeHandler.class);
 	}
 
-	public static void mockRuntime(File rootPathF, File configSrc) {
+	public PersistenceHandler getPersistenceHandler() {
+		return this.container.getComponent(PersistenceHandler.class);
+	}
+
+	public void mockRuntime(File rootPathF, File configSrc) {
 
 		if (!rootPathF.getParentFile().getName().equals(TARGET)) {
 			String msg = "Mocking path must be in a maven target: {0}"; //$NON-NLS-1$
@@ -90,7 +91,7 @@ public class RuntimeMock {
 		}
 	}
 
-	public static void startContainer(File rootPathF) {
+	public void startContainer(File rootPathF) {
 
 		try {
 			StrolchAgent agent = new StrolchAgent();
@@ -98,8 +99,8 @@ public class RuntimeMock {
 			agent.initialize();
 			agent.start();
 
-			RuntimeMock.agent = agent;
-			RuntimeMock.container = agent.getContainer();
+			this.agent = agent;
+			this.container = agent.getContainer();
 
 		} catch (Exception e) {
 			logger.error("Failed to start mocked container due to: " + e.getMessage(), e); //$NON-NLS-1$
@@ -108,19 +109,19 @@ public class RuntimeMock {
 		}
 	}
 
-	public static void destroyRuntime() {
+	public void destroyRuntime() {
 
-		if (agent == null)
+		if (this.agent == null)
 			return;
 
 		try {
-			agent.stop();
+			this.agent.stop();
 		} catch (Exception e) {
 			logger.info("Failed to stop container: " + e.getMessage()); //$NON-NLS-1$
 		}
 
 		try {
-			agent.destroy();
+			this.agent.destroy();
 		} catch (Exception e) {
 			logger.info("Failed to destroy container: " + e.getMessage()); //$NON-NLS-1$
 		}