org.eclipse.mdm.nucleus/org.eclipse.mdm.businessobjects/src/test/java/org/eclipse/mdm/businessobjects/boundary/integrationtest/EntityResourceIntegrationTest.java - mdmbl/org.eclipse.mdm - Git at Google

 /********************************************************************************
  * Copyright (c) 2015-2018 Contributors to the Eclipse Foundation
  *
  * See the NOTICE file(s) distributed with this work for additional
  * information regarding copyright ownership.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  ********************************************************************************/

 package org.eclipse.mdm.businessobjects.boundary.integrationtest;

 import static io.restassured.RestAssured.given;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.notNullValue;

 import java.util.NoSuchElementException;

 import org.junit.Assume;
 import org.junit.FixMethodOrder;
 import org.junit.Test;
 import org.junit.runners.MethodSorters;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import com.google.gson.JsonObject;
 import com.google.gson.JsonParser;
 import com.google.gson.JsonPrimitive;

 import io.restassured.RestAssured;
 import io.restassured.authentication.PreemptiveBasicAuthScheme;
 import io.restassured.http.ContentType;
 import io.restassured.response.ExtractableResponse;
 import io.restassured.response.Response;
 import io.vavr.collection.HashMap;
 import io.vavr.collection.HashSet;
 import io.vavr.collection.Map;
 import io.vavr.collection.Set;

 /**
  * Abstract test class for Entity resources. Tests are executed in
  * {@code FixMethodOrder(MethodSorters.NAME_ASCENDING)} as {@link test1Create},
  * {@link test2Find()}, {@link test3FindAll()}, {@link test4Update()} and
  * {@link test5Delete()} depend on the entity created by test1Create().
  *
  * @author Alexander Nehmer, science+computing AG Tuebingen (Atos SE)
  *
  */
 // TODO anehmer on 2017-11-23: test for specific return codes
 // TODO anehmer on 2017-11-24: expand tests to localization and search attribute
 // information
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 public abstract class EntityResourceIntegrationTest {

 	private static Logger LOGGER = LoggerFactory.getLogger(EntityResourceIntegrationTest.class);

 	private static final String HOST = "localhost";
 	private static final String PORT = "8080";
 	private static final String BASE_PATH = "org.eclipse.mdm.nucleus";
 	private static final String API_PATH = "mdm";
 	private static final String ENV_PATH = "environments/PODS";

 	private static final String AUTH_USERNAME = "sa";
 	private static final String AUTH_PASSWORD = "sa";

 	protected final static String TESTDATA_ENTITY_ID = "entityId";
 	protected final static String TESTDATA_ENTITY_NAME = "entityName";
 	protected final static String TESTDATA_ENTITY_TYPE = "entityType";
 	protected final static String TESTDATA_CREATE_JSON_BODY = "createJSONBody";
 	protected final static String TESTDATA_UPDATE_JSON_BODY = "updateJSONBody";
 	protected final static String TESTDATA_RESOURCE_URI = "resourceURI";
 	protected final static String TESTDATA_RANDOM_DATA = "RANDOM_DATA";

 	private static final String RANDOM_ENTITY_NAME_SUFFIX = "_" + Long.toHexString(System.currentTimeMillis());

 	public enum TestType {
 		CREATE, FIND, FINDALL, UPDATE, DELETE;
 	}

 	private static Map<Class<?>, Set<TestType>> testsToSkip = HashMap.empty();

 	private static Map<Class<?>, Map<String, String>> testDataMap = HashMap.empty();

 	// if this is set, the resource URI for find() is constructed with the name as
 	// the PATH_PARAM
 	private static Map<Class<?>, Boolean> findByName = HashMap.empty();

 	/**
 	 * The context class must be set by implementing tests as the context to get
 	 * from and put test data values to
 	 */
 	private static Class<?> contextClass;

 	/**
 	 * Init RestAssured
 	 */
 	static {
 		// configure URI
 		StringBuilder baseURI = new StringBuilder();
 		baseURI.append("http://")
 				.append(HOST)
 				.append(":")
 				.append(PORT)
 				.append("/")
 				.append(BASE_PATH)
 				.append("/")
 				.append(API_PATH);
 		RestAssured.baseURI = baseURI.toString();
 		RestAssured.basePath = ENV_PATH;

 		LOGGER.debug("RestAssured set up to " + RestAssured.baseURI + "/" + RestAssured.basePath);

 		// setup authentication
 		PreemptiveBasicAuthScheme authScheme = new PreemptiveBasicAuthScheme();
 		authScheme.setUserName(AUTH_USERNAME);
 		authScheme.setPassword(AUTH_PASSWORD);

 		RestAssured.authentication = authScheme;

 		LOGGER.debug("RestAssured authentication set to credentials [" + AUTH_USERNAME + "]/[" + AUTH_PASSWORD + "]");
 	}

 	@Test
 	public void test1Create() {
 		// only execute if not skipped by implementing test class
 		Assume.assumeFalse(testsToSkip.get(getContextClass())
 				.get()
 				.contains(TestType.CREATE));

 		createEntity();
 	}

 	/**
 	 * Static method that can be utilised by tests to create a specific entity or is
 	 * called indirectly by JUnit
 	 */
 	public static void createEntity() {
 		// do not create entity if it was already created in a currently running
 		// prepareTestData() cascade
 		if (isTestDataValuePresent(TESTDATA_ENTITY_ID)) {
 			LOGGER.debug(getContextClass().getSimpleName() + ".create() aborted as entity "
 					+ getTestDataValue(TESTDATA_ENTITY_NAME) + " of type " + getTestDataValue(TESTDATA_ENTITY_TYPE)
 					+ " was already created");
 			return;
 		}

 		LOGGER.debug(getContextClass().getSimpleName() + ".create() sending POST to "
 				+ getTestDataValue(TESTDATA_RESOURCE_URI) + " with: " + getTestDataValue(TESTDATA_CREATE_JSON_BODY));

 		ExtractableResponse<io.restassured.response.Response> response = given().contentType(ContentType.JSON)
 				.body(getTestDataValue(TESTDATA_CREATE_JSON_BODY))
 				.post(getTestDataValue(TESTDATA_RESOURCE_URI))
 				.then()
 				.log()
 				.ifError()
 				.contentType(ContentType.JSON)
 				// do not check for name equality as that might be created randomly
 				.and()
 				.body("data.first().type", equalTo(getTestDataValue(TESTDATA_ENTITY_TYPE)))
 				.extract();

 		LOGGER.debug(getContextClass().getSimpleName() + " created " + response.asString());

 		putTestDataValue(TESTDATA_ENTITY_ID, response.path("data.first().id"));
 		putTestDataValue(TESTDATA_ENTITY_NAME, response.path("data.first().name"));
 	}

 	@Test
 	public void test2Find() {
 		// only execute if not skipped by implementing test class
 		Assume.assumeFalse(testsToSkip.get(getContextClass())
 				.get()
 				.contains(TestType.FIND));

 		String uri = getTestDataValue(TESTDATA_RESOURCE_URI) + "/"
 				+ (EntityResourceIntegrationTest.findByName.getOrElse(getContextClass(), false)
 						? getTestDataValue(TESTDATA_ENTITY_NAME)
 						: getTestDataValue(TESTDATA_ENTITY_ID));

 		LOGGER.debug(getContextClass().getSimpleName() + ".find() sending GET to " + uri);

 		ExtractableResponse<Response> response = given().get(uri)
 				.then()
 				.log()
 				.ifError()
 				.contentType(ContentType.JSON)
 				.body("data.first().name", equalTo(getTestDataValue(TESTDATA_ENTITY_NAME)))
 				.body("data.first().type", equalTo(getTestDataValue(TESTDATA_ENTITY_TYPE)))
 				.extract();

 		LOGGER.debug(getContextClass().getSimpleName() + " found " + response.asString());
 	}

 	/**
 	 * Finds the first entity of the {@code EntityType} set in the context and put
 	 * the found ID in the context for further usage
 	 */
 	public static void findFirst() {
 		LOGGER.debug(getContextClass().getSimpleName() + ".find() sending GET to "
 				+ getTestDataValue(TESTDATA_RESOURCE_URI));

 		String id = given().get(getTestDataValue(TESTDATA_RESOURCE_URI))
 				.then()
 				.log()
 				.ifError()
 				.contentType(ContentType.JSON)
 				.body("data.first().name", equalTo(getTestDataValue(TESTDATA_ENTITY_NAME)))
 				.body("data.first().type", equalTo(getTestDataValue(TESTDATA_ENTITY_TYPE)))
 				.extract()
 				.path("data.first().id");

 		LOGGER.debug(getContextClass().getSimpleName() + " found " + getTestDataValue(TESTDATA_ENTITY_TYPE)
 				+ " with ID " + id);

 		putTestDataValue(TESTDATA_ENTITY_ID, id);
 	}

 	@Test
 	public void test3FindAll() {
 		// only execute if not skipped by implementing test class
 		Assume.assumeFalse(testsToSkip.get(getContextClass())
 				.get()
 				.contains(TestType.FINDALL));

 		LOGGER.debug(getContextClass().getSimpleName() + ".findAll() sending GET to "
 				+ getTestDataValue(TESTDATA_RESOURCE_URI));

 		ExtractableResponse<Response> response = given().get(getTestDataValue(TESTDATA_RESOURCE_URI))
 				.then()
 				.log()
 				.ifError()
 				.contentType(ContentType.JSON)
 				.body("data.first().type", equalTo(getTestDataValue(TESTDATA_ENTITY_TYPE)))
 				.extract();

 		LOGGER.debug(getContextClass().getSimpleName() + " found all " + response.asString());
 	}

 	// TODO anehmer on 2017-11-09: test findAll with filter

 	// TODO anehmer on 2018-02-06: update of relations are not checked as the
 	// returned Json does not include relations
 	@Test
 	public void test4Update() {
 		// only execute if not skipped by implementing test class
 		Assume.assumeFalse(testsToSkip.get(getContextClass())
 				.get()
 				.contains(TestType.UPDATE));

 		JsonObject json;
 		// if no UPDATE_JSON_BODY is defined in implementing test, just run the MimeType
 		// update
 		if (!isTestDataValuePresent(TESTDATA_UPDATE_JSON_BODY)) {
 			json = new JsonObject();
 		}
 		// or add it to the existing update
 		else {
 			json = new JsonParser().parse(getTestDataValue(TESTDATA_UPDATE_JSON_BODY))
 					.getAsJsonObject();
 		}
 		json.add("MimeType", new JsonPrimitive("updatedMimeType"));
 		putTestDataValue(TESTDATA_UPDATE_JSON_BODY, json.toString());

 		String uri = getTestDataValue(TESTDATA_RESOURCE_URI) + "/" + getTestDataValue(TESTDATA_ENTITY_ID);

 		LOGGER.debug(getContextClass().getSimpleName() + ".update() sending PUT to " + uri + " with: "
 				+ getTestDataValue(TESTDATA_UPDATE_JSON_BODY));

 		ExtractableResponse<Response> response = given().contentType(ContentType.JSON)
 				// TODO anehmer on 2017-11-15: the update should use different data but as the
 				// returned JSON represents
 				// the entity prior update it does not make any difference as the update is
 				// performed just based on identical data. We should discuss the PUT-behaviour
 				// instead: return the old or updated object as returning the updated one would
 				// mean to perform another get as the ODSTransaction.update() does not return
 				// the updated entity
 				// TODO anehmer on 2017-11-15: use Description to test update
 				.body(getTestDataValue(TESTDATA_UPDATE_JSON_BODY))
 				.put(uri)
 				.then()
 				.log()
 				.ifError()
 				.contentType(ContentType.JSON)
 				.body("data.first().name", equalTo(getTestDataValue(TESTDATA_ENTITY_NAME)))
 				.body("data.first().type", equalTo(getTestDataValue(TESTDATA_ENTITY_TYPE)))
 				.body("data.first().attributes.find {it.name == 'MimeType'}.value", equalTo("updatedMimeType"))
 				.extract();

 		LOGGER.debug(getContextClass().getSimpleName() + " updated " + response.asString());
 	}

 	@Test
 	public void test5Delete() {
 		// only execute if not skipped by implementing test class
 		Assume.assumeFalse(testsToSkip.get(getContextClass())
 				.get()
 				.contains(TestType.DELETE));

 		deleteEntity();
 	}

 	/**
 	 * Static method that can be utilised by tests to delete a specific entity or is
 	 * called indirectly by JUnit
 	 */
 	public static void deleteEntity() {
 		String uri = getTestDataValue(TESTDATA_RESOURCE_URI) + "/" + getTestDataValue(TESTDATA_ENTITY_ID);

 		LOGGER.debug(getContextClass().getSimpleName() + ".delete() sending DELETE to " + uri);

 		ExtractableResponse<Response> response = given().delete(uri)
 				.then()
 				.log()
 				.ifError()
 				.body("data.first().name", equalTo(getTestDataValue(TESTDATA_ENTITY_NAME)))
 				.body("data.first().type", equalTo(getTestDataValue(TESTDATA_ENTITY_TYPE)))
 				.extract();

 		LOGGER.debug(getContextClass().getSimpleName() + " deleted " + response.asString());

 		removeTestDataValue(TESTDATA_ENTITY_ID);
 	}

 	/**
 	 * Gets value with key from the testDataMap. The value map is thereby
 	 * automatically identified by the implementing class.
 	 *
 	 * @param key
 	 *            key to get value for
 	 * @return value for given key
 	 */
 	public static String getTestDataValue(String key) {
 		return getTestDataValue(getContextClass(), key);
 	}

 	/**
 	 * Gets value with key from the testDataMap using the context specified by
 	 * contextClass
 	 *
 	 * @param contextClass
 	 *            the class of the test implementation
 	 * @param key
 	 *            key to get value for
 	 * @return value for given key
 	 */
 	public static String getTestDataValue(Class<?> contextClass, String key) {
 		return testDataMap.get(contextClass)
 				.map(valueMap -> valueMap.get(key)
 						.getOrElseThrow(() -> new NoSuchElementException(
 								"Key [" + key + "] not found in test data value map in context ["
 										+ contextClass.getSimpleName() + "]")))
 				.get();
 	}

 	/**
 	 * Checks if a test data value is present for the given key
 	 *
 	 * @param key
 	 *            key to check presence of test data value for
 	 * @return true, if a test data value for the given key exists, false if not
 	 */
 	public static boolean isTestDataValuePresent(String key) {
 		return testDataMap.get(getContextClass())
 				.map(valueMap -> valueMap.get(key)
 						.isDefined())
 				.get();
 	}

 	/**
 	 * Removes the test data value for the given key. If the key is not present,
 	 * nothing happens.
 	 *
 	 * @param key
 	 *            key to remove test data value for
 	 */
 	public static void removeTestDataValue(String key) {
 		testDataMap.get(getContextClass())
 				.map(valueMap -> valueMap.remove(key))
 				.map(newValueMap -> testDataMap = testDataMap.put(getContextClass(), newValueMap));
 	}

 	/**
 	 * Puts value with key in the testDataMap. The value map is thereby
 	 * automatically identified by the implementing class.
 	 *
 	 * @param key
 	 *            key to store value under
 	 * @param value
 	 *            value to store
 	 */
 	public static void putTestDataValue(String key, String value) {
 		Map<String, String> entityTestData = testDataMap.getOrElse(getContextClass(), HashMap.empty());

 		// randomize name to allow failure runs not to require to reset the
 		// database in case the name of the entity must be unique
 		// do not append suffix if name is randomly generated
 		if (key.equals(TESTDATA_ENTITY_NAME) && !value.equals(TESTDATA_RANDOM_DATA)
 				&& (entityTestData.get(TESTDATA_ENTITY_NAME)
 						.isEmpty()
 						|| !entityTestData.get(TESTDATA_ENTITY_NAME)
 								.get()
 								.equals(TESTDATA_RANDOM_DATA))) {
 			// append suffix if it was not already appended or an already suffixed value was
 			// used for a new one (e.g: TplAttr.name and CatAttr.name)
 			if (!value.endsWith(RANDOM_ENTITY_NAME_SUFFIX)) {
 				value = value + RANDOM_ENTITY_NAME_SUFFIX;
 			}
 		}

 		entityTestData = entityTestData.put(key, value);

 		testDataMap = testDataMap.put(getContextClass(), entityTestData);
 	}

 	/**
 	 * Gets the context class set by a test implementation used to store context
 	 * aware test data
 	 *
 	 * @return the context class of the test implementation
 	 */
 	private static Class<?> getContextClass() {
 		assertThat(contextClass, is(notNullValue()));
 		return contextClass;
 	}

 	/**
 	 * Sets the context class used to store context aware test data. This method
 	 * must be called by any test implementation before using
 	 * {@link getTestDataValue} or {@link putTestDataValue}
 	 *
 	 * @param contextClass
 	 *            the context class set by a test implementation
 	 */
 	public static void setContextClass(Class<?> contextClass) {
 		EntityResourceIntegrationTest.contextClass = contextClass;
 		testsToSkip = testsToSkip.put(contextClass, HashSet.empty());
 		LOGGER = LoggerFactory.getLogger(contextClass);
 	}

 	/**
 	 * Set the test with the given {@link TestType} to be skipped
 	 *
 	 * @param testType
 	 *            the test to skip
 	 */
 	public static void skipTest(TestType test) {
 		testsToSkip.get(getContextClass())
 				.map(tests -> tests.add(test))
 				.map(newTests -> testsToSkip = testsToSkip.put(getContextClass(), newTests));
 	}

 	/**
 	 * Sets the option findByName to either true or false. If it's set to true, the
 	 * URI for find() is constructed with the name rather than with the id of the
 	 * entity as the PATH_PARAM
 	 *
 	 * @param findByName
 	 *            if find() should use the name instead of the id of the entity
 	 */
 	public static void setFindByName(boolean findByNameValue) {
 		findByName = findByName.put(getContextClass(), findByNameValue);
 	}

 	/**
 	 * Gets the logger
 	 *
 	 * @return logger configured to current context class
 	 */
 	public static Logger getLogger() {
 		return LOGGER;
 	}
 }
	/********************************************************************************
	* Copyright (c) 2015-2018 Contributors to the Eclipse Foundation
	*
	* See the NOTICE file(s) distributed with this work for additional
	* information regarding copyright ownership.
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0.
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	********************************************************************************/

	package org.eclipse.mdm.businessobjects.boundary.integrationtest;

	import static io.restassured.RestAssured.given;
	import static org.hamcrest.MatcherAssert.assertThat;
	import static org.hamcrest.Matchers.equalTo;
	import static org.hamcrest.Matchers.is;
	import static org.hamcrest.Matchers.notNullValue;

	import java.util.NoSuchElementException;

	import org.junit.Assume;
	import org.junit.FixMethodOrder;
	import org.junit.Test;
	import org.junit.runners.MethodSorters;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import com.google.gson.JsonObject;
	import com.google.gson.JsonParser;
	import com.google.gson.JsonPrimitive;

	import io.restassured.RestAssured;
	import io.restassured.authentication.PreemptiveBasicAuthScheme;
	import io.restassured.http.ContentType;
	import io.restassured.response.ExtractableResponse;
	import io.restassured.response.Response;
	import io.vavr.collection.HashMap;
	import io.vavr.collection.HashSet;
	import io.vavr.collection.Map;
	import io.vavr.collection.Set;

	/**
	* Abstract test class for Entity resources. Tests are executed in
	* {@code FixMethodOrder(MethodSorters.NAME_ASCENDING)} as {@link test1Create},
	* {@link test2Find()}, {@link test3FindAll()}, {@link test4Update()} and
	* {@link test5Delete()} depend on the entity created by test1Create().
	*
	* @author Alexander Nehmer, science+computing AG Tuebingen (Atos SE)
	*
	*/
	// TODO anehmer on 2017-11-23: test for specific return codes
	// TODO anehmer on 2017-11-24: expand tests to localization and search attribute
	// information
	@FixMethodOrder(MethodSorters.NAME_ASCENDING)
	public abstract class EntityResourceIntegrationTest {

	private static Logger LOGGER = LoggerFactory.getLogger(EntityResourceIntegrationTest.class);

	private static final String HOST = "localhost";
	private static final String PORT = "8080";
	private static final String BASE_PATH = "org.eclipse.mdm.nucleus";
	private static final String API_PATH = "mdm";
	private static final String ENV_PATH = "environments/PODS";

	private static final String AUTH_USERNAME = "sa";
	private static final String AUTH_PASSWORD = "sa";

	protected final static String TESTDATA_ENTITY_ID = "entityId";
	protected final static String TESTDATA_ENTITY_NAME = "entityName";
	protected final static String TESTDATA_ENTITY_TYPE = "entityType";
	protected final static String TESTDATA_CREATE_JSON_BODY = "createJSONBody";
	protected final static String TESTDATA_UPDATE_JSON_BODY = "updateJSONBody";
	protected final static String TESTDATA_RESOURCE_URI = "resourceURI";
	protected final static String TESTDATA_RANDOM_DATA = "RANDOM_DATA";

	private static final String RANDOM_ENTITY_NAME_SUFFIX = "_" + Long.toHexString(System.currentTimeMillis());

	public enum TestType {
	CREATE, FIND, FINDALL, UPDATE, DELETE;
	}

	private static Map<Class<?>, Set<TestType>> testsToSkip = HashMap.empty();

	private static Map<Class<?>, Map<String, String>> testDataMap = HashMap.empty();

	// if this is set, the resource URI for find() is constructed with the name as
	// the PATH_PARAM
	private static Map<Class<?>, Boolean> findByName = HashMap.empty();

	/**
	* The context class must be set by implementing tests as the context to get
	* from and put test data values to
	*/
	private static Class<?> contextClass;

	/**
	* Init RestAssured
	*/
	static {
	// configure URI
	StringBuilder baseURI = new StringBuilder();
	baseURI.append("http://")
	.append(HOST)
	.append(":")
	.append(PORT)
	.append("/")
	.append(BASE_PATH)
	.append("/")
	.append(API_PATH);
	RestAssured.baseURI = baseURI.toString();
	RestAssured.basePath = ENV_PATH;

	LOGGER.debug("RestAssured set up to " + RestAssured.baseURI + "/" + RestAssured.basePath);

	// setup authentication
	PreemptiveBasicAuthScheme authScheme = new PreemptiveBasicAuthScheme();
	authScheme.setUserName(AUTH_USERNAME);
	authScheme.setPassword(AUTH_PASSWORD);

	RestAssured.authentication = authScheme;

	LOGGER.debug("RestAssured authentication set to credentials [" + AUTH_USERNAME + "]/[" + AUTH_PASSWORD + "]");
	}

	@Test
	public void test1Create() {
	// only execute if not skipped by implementing test class
	Assume.assumeFalse(testsToSkip.get(getContextClass())
	.get()
	.contains(TestType.CREATE));

	createEntity();
	}

	/**
	* Static method that can be utilised by tests to create a specific entity or is
	* called indirectly by JUnit
	*/
	public static void createEntity() {
	// do not create entity if it was already created in a currently running
	// prepareTestData() cascade
	if (isTestDataValuePresent(TESTDATA_ENTITY_ID)) {
	LOGGER.debug(getContextClass().getSimpleName() + ".create() aborted as entity "
	+ getTestDataValue(TESTDATA_ENTITY_NAME) + " of type " + getTestDataValue(TESTDATA_ENTITY_TYPE)
	+ " was already created");
	return;
	}

	LOGGER.debug(getContextClass().getSimpleName() + ".create() sending POST to "
	+ getTestDataValue(TESTDATA_RESOURCE_URI) + " with: " + getTestDataValue(TESTDATA_CREATE_JSON_BODY));

	ExtractableResponse<io.restassured.response.Response> response = given().contentType(ContentType.JSON)
	.body(getTestDataValue(TESTDATA_CREATE_JSON_BODY))
	.post(getTestDataValue(TESTDATA_RESOURCE_URI))
	.then()
	.log()
	.ifError()
	.contentType(ContentType.JSON)
	// do not check for name equality as that might be created randomly
	.and()
	.body("data.first().type", equalTo(getTestDataValue(TESTDATA_ENTITY_TYPE)))
	.extract();

	LOGGER.debug(getContextClass().getSimpleName() + " created " + response.asString());

	putTestDataValue(TESTDATA_ENTITY_ID, response.path("data.first().id"));
	putTestDataValue(TESTDATA_ENTITY_NAME, response.path("data.first().name"));
	}

	@Test
	public void test2Find() {
	// only execute if not skipped by implementing test class
	Assume.assumeFalse(testsToSkip.get(getContextClass())
	.get()
	.contains(TestType.FIND));

	String uri = getTestDataValue(TESTDATA_RESOURCE_URI) + "/"
	+ (EntityResourceIntegrationTest.findByName.getOrElse(getContextClass(), false)
	? getTestDataValue(TESTDATA_ENTITY_NAME)
	: getTestDataValue(TESTDATA_ENTITY_ID));

	LOGGER.debug(getContextClass().getSimpleName() + ".find() sending GET to " + uri);

	ExtractableResponse<Response> response = given().get(uri)
	.then()
	.log()
	.ifError()
	.contentType(ContentType.JSON)
	.body("data.first().name", equalTo(getTestDataValue(TESTDATA_ENTITY_NAME)))
	.body("data.first().type", equalTo(getTestDataValue(TESTDATA_ENTITY_TYPE)))
	.extract();

	LOGGER.debug(getContextClass().getSimpleName() + " found " + response.asString());
	}

	/**
	* Finds the first entity of the {@code EntityType} set in the context and put
	* the found ID in the context for further usage
	*/
	public static void findFirst() {
	LOGGER.debug(getContextClass().getSimpleName() + ".find() sending GET to "
	+ getTestDataValue(TESTDATA_RESOURCE_URI));

	String id = given().get(getTestDataValue(TESTDATA_RESOURCE_URI))
	.then()
	.log()
	.ifError()
	.contentType(ContentType.JSON)
	.body("data.first().name", equalTo(getTestDataValue(TESTDATA_ENTITY_NAME)))
	.body("data.first().type", equalTo(getTestDataValue(TESTDATA_ENTITY_TYPE)))
	.extract()
	.path("data.first().id");

	LOGGER.debug(getContextClass().getSimpleName() + " found " + getTestDataValue(TESTDATA_ENTITY_TYPE)
	+ " with ID " + id);

	putTestDataValue(TESTDATA_ENTITY_ID, id);
	}

	@Test
	public void test3FindAll() {
	// only execute if not skipped by implementing test class
	Assume.assumeFalse(testsToSkip.get(getContextClass())
	.get()
	.contains(TestType.FINDALL));

	LOGGER.debug(getContextClass().getSimpleName() + ".findAll() sending GET to "
	+ getTestDataValue(TESTDATA_RESOURCE_URI));

	ExtractableResponse<Response> response = given().get(getTestDataValue(TESTDATA_RESOURCE_URI))
	.then()
	.log()
	.ifError()
	.contentType(ContentType.JSON)
	.body("data.first().type", equalTo(getTestDataValue(TESTDATA_ENTITY_TYPE)))
	.extract();

	LOGGER.debug(getContextClass().getSimpleName() + " found all " + response.asString());
	}

	// TODO anehmer on 2017-11-09: test findAll with filter

	// TODO anehmer on 2018-02-06: update of relations are not checked as the
	// returned Json does not include relations
	@Test
	public void test4Update() {
	// only execute if not skipped by implementing test class
	Assume.assumeFalse(testsToSkip.get(getContextClass())
	.get()
	.contains(TestType.UPDATE));

	JsonObject json;
	// if no UPDATE_JSON_BODY is defined in implementing test, just run the MimeType
	// update
	if (!isTestDataValuePresent(TESTDATA_UPDATE_JSON_BODY)) {
	json = new JsonObject();
	}
	// or add it to the existing update
	else {
	json = new JsonParser().parse(getTestDataValue(TESTDATA_UPDATE_JSON_BODY))
	.getAsJsonObject();
	}
	json.add("MimeType", new JsonPrimitive("updatedMimeType"));
	putTestDataValue(TESTDATA_UPDATE_JSON_BODY, json.toString());

	String uri = getTestDataValue(TESTDATA_RESOURCE_URI) + "/" + getTestDataValue(TESTDATA_ENTITY_ID);

	LOGGER.debug(getContextClass().getSimpleName() + ".update() sending PUT to " + uri + " with: "
	+ getTestDataValue(TESTDATA_UPDATE_JSON_BODY));

	ExtractableResponse<Response> response = given().contentType(ContentType.JSON)
	// TODO anehmer on 2017-11-15: the update should use different data but as the
	// returned JSON represents
	// the entity prior update it does not make any difference as the update is
	// performed just based on identical data. We should discuss the PUT-behaviour
	// instead: return the old or updated object as returning the updated one would
	// mean to perform another get as the ODSTransaction.update() does not return
	// the updated entity
	// TODO anehmer on 2017-11-15: use Description to test update
	.body(getTestDataValue(TESTDATA_UPDATE_JSON_BODY))
	.put(uri)
	.then()
	.log()
	.ifError()
	.contentType(ContentType.JSON)
	.body("data.first().name", equalTo(getTestDataValue(TESTDATA_ENTITY_NAME)))
	.body("data.first().type", equalTo(getTestDataValue(TESTDATA_ENTITY_TYPE)))
	.body("data.first().attributes.find {it.name == 'MimeType'}.value", equalTo("updatedMimeType"))
	.extract();

	LOGGER.debug(getContextClass().getSimpleName() + " updated " + response.asString());
	}

	@Test
	public void test5Delete() {
	// only execute if not skipped by implementing test class
	Assume.assumeFalse(testsToSkip.get(getContextClass())
	.get()
	.contains(TestType.DELETE));

	deleteEntity();
	}

	/**
	* Static method that can be utilised by tests to delete a specific entity or is
	* called indirectly by JUnit
	*/
	public static void deleteEntity() {
	String uri = getTestDataValue(TESTDATA_RESOURCE_URI) + "/" + getTestDataValue(TESTDATA_ENTITY_ID);

	LOGGER.debug(getContextClass().getSimpleName() + ".delete() sending DELETE to " + uri);

	ExtractableResponse<Response> response = given().delete(uri)
	.then()
	.log()
	.ifError()
	.body("data.first().name", equalTo(getTestDataValue(TESTDATA_ENTITY_NAME)))
	.body("data.first().type", equalTo(getTestDataValue(TESTDATA_ENTITY_TYPE)))
	.extract();

	LOGGER.debug(getContextClass().getSimpleName() + " deleted " + response.asString());

	removeTestDataValue(TESTDATA_ENTITY_ID);
	}

	/**
	* Gets value with key from the testDataMap. The value map is thereby
	* automatically identified by the implementing class.
	*
	* @param key
	* key to get value for
	* @return value for given key
	*/
	public static String getTestDataValue(String key) {
	return getTestDataValue(getContextClass(), key);
	}

	/**
	* Gets value with key from the testDataMap using the context specified by
	* contextClass
	*
	* @param contextClass
	* the class of the test implementation
	* @param key
	* key to get value for
	* @return value for given key
	*/
	public static String getTestDataValue(Class<?> contextClass, String key) {
	return testDataMap.get(contextClass)
	.map(valueMap -> valueMap.get(key)
	.getOrElseThrow(() -> new NoSuchElementException(
	"Key [" + key + "] not found in test data value map in context ["
	+ contextClass.getSimpleName() + "]")))
	.get();
	}

	/**
	* Checks if a test data value is present for the given key
	*
	* @param key
	* key to check presence of test data value for
	* @return true, if a test data value for the given key exists, false if not
	*/
	public static boolean isTestDataValuePresent(String key) {
	return testDataMap.get(getContextClass())
	.map(valueMap -> valueMap.get(key)
	.isDefined())
	.get();
	}

	/**
	* Removes the test data value for the given key. If the key is not present,
	* nothing happens.
	*
	* @param key
	* key to remove test data value for
	*/
	public static void removeTestDataValue(String key) {
	testDataMap.get(getContextClass())
	.map(valueMap -> valueMap.remove(key))
	.map(newValueMap -> testDataMap = testDataMap.put(getContextClass(), newValueMap));
	}

	/**
	* Puts value with key in the testDataMap. The value map is thereby
	* automatically identified by the implementing class.
	*
	* @param key
	* key to store value under
	* @param value
	* value to store
	*/
	public static void putTestDataValue(String key, String value) {
	Map<String, String> entityTestData = testDataMap.getOrElse(getContextClass(), HashMap.empty());

	// randomize name to allow failure runs not to require to reset the
	// database in case the name of the entity must be unique
	// do not append suffix if name is randomly generated
	if (key.equals(TESTDATA_ENTITY_NAME) && !value.equals(TESTDATA_RANDOM_DATA)
	&& (entityTestData.get(TESTDATA_ENTITY_NAME)
	.isEmpty()
	\|\| !entityTestData.get(TESTDATA_ENTITY_NAME)
	.get()
	.equals(TESTDATA_RANDOM_DATA))) {
	// append suffix if it was not already appended or an already suffixed value was
	// used for a new one (e.g: TplAttr.name and CatAttr.name)
	if (!value.endsWith(RANDOM_ENTITY_NAME_SUFFIX)) {
	value = value + RANDOM_ENTITY_NAME_SUFFIX;
	}
	}

	entityTestData = entityTestData.put(key, value);

	testDataMap = testDataMap.put(getContextClass(), entityTestData);
	}

	/**
	* Gets the context class set by a test implementation used to store context
	* aware test data
	*
	* @return the context class of the test implementation
	*/
	private static Class<?> getContextClass() {
	assertThat(contextClass, is(notNullValue()));
	return contextClass;
	}

	/**
	* Sets the context class used to store context aware test data. This method
	* must be called by any test implementation before using
	* {@link getTestDataValue} or {@link putTestDataValue}
	*
	* @param contextClass
	* the context class set by a test implementation
	*/
	public static void setContextClass(Class<?> contextClass) {
	EntityResourceIntegrationTest.contextClass = contextClass;
	testsToSkip = testsToSkip.put(contextClass, HashSet.empty());
	LOGGER = LoggerFactory.getLogger(contextClass);
	}

	/**
	* Set the test with the given {@link TestType} to be skipped
	*
	* @param testType
	* the test to skip
	*/
	public static void skipTest(TestType test) {
	testsToSkip.get(getContextClass())
	.map(tests -> tests.add(test))
	.map(newTests -> testsToSkip = testsToSkip.put(getContextClass(), newTests));
	}

	/**
	* Sets the option findByName to either true or false. If it's set to true, the
	* URI for find() is constructed with the name rather than with the id of the
	* entity as the PATH_PARAM
	*
	* @param findByName
	* if find() should use the name instead of the id of the entity
	*/
	public static void setFindByName(boolean findByNameValue) {
	findByName = findByName.put(getContextClass(), findByNameValue);
	}

	/**
	* Gets the logger
	*
	* @return logger configured to current context class
	*/
	public static Logger getLogger() {
	return LOGGER;
	}
	}