nucleus/businessobjects/src/test/java/org/eclipse/mdm/nodeprovider/control/GenericNodeProviderTest.java - mdmbl/org.eclipse.mdm - Git at Google

 package org.eclipse.mdm.nodeprovider.control;

 import static org.assertj.core.api.Assertions.assertThat;
 import static org.eclipse.mdm.api.odsadapter.ODSContextFactory.PARAM_NAMESERVICE;
 import static org.eclipse.mdm.api.odsadapter.ODSContextFactory.PARAM_PASSWORD;
 import static org.eclipse.mdm.api.odsadapter.ODSContextFactory.PARAM_SERVICENAME;
 import static org.eclipse.mdm.api.odsadapter.ODSContextFactory.PARAM_USER;
 import static org.mockito.ArgumentMatchers.any;

 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.mdm.api.base.ConnectionException;
 import org.eclipse.mdm.api.base.adapter.EntityType;
 import org.eclipse.mdm.api.base.adapter.ModelManager;
 import org.eclipse.mdm.api.base.model.Channel;
 import org.eclipse.mdm.api.base.model.ChannelGroup;
 import org.eclipse.mdm.api.base.model.Environment;
 import org.eclipse.mdm.api.base.model.Measurement;
 import org.eclipse.mdm.api.base.model.TestStep;
 import org.eclipse.mdm.api.base.search.ContextState;
 import org.eclipse.mdm.api.dflt.ApplicationContext;
 import org.eclipse.mdm.api.dflt.model.Project;
 import org.eclipse.mdm.api.odsadapter.ODSContextFactory;
 import org.eclipse.mdm.connector.boundary.ConnectorService;
 import org.eclipse.mdm.nodeprovider.entity.NodeLevel;
 import org.eclipse.mdm.nodeprovider.entity.NodeProviderRoot;
 import org.eclipse.mdm.nodeprovider.entity.SortAttribute;
 import org.eclipse.mdm.nodeprovider.utils.SerializationUtil;
 import org.eclipse.mdm.protobuf.Mdm.Node;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.Ignore;
 import org.junit.Test;
 import org.mockito.Mockito;

 import com.google.common.collect.ImmutableMap;

 import junit.framework.AssertionFailedError;

 @Ignore
 //FIXME 25.11.2020: this test needs a running ODS Server, that is not suitable for continous build in Jenkins.
 //Comment this in for local tests only.
 public class GenericNodeProviderTest {
 	/*
 	 * ATTENTION: ==========
 	 *
 	 * To run this test make sure the target service is running a MDM default model
 	 * and any database constraint which enforces a relation of Test to a parent
 	 * entity is deactivated!
 	 */

 	private static final String NAME_SERVICE = "corbaloc::1.2@%s:%s/NameService";

 	private static final String USER = "sa";
 	private static final String PASSWORD = "sa";

 	private static ApplicationContext context;

 	@BeforeClass
 	public static void setUpBeforeClass() throws ConnectionException {
 		String nameServiceHost = System.getProperty("host");
 		String nameServicePort = System.getProperty("port");
 		String serviceName = System.getProperty("service");

 		if (nameServiceHost == null || nameServiceHost.isEmpty()) {
 			throw new IllegalArgumentException("name service host is unknown: define system property 'host'");
 		}

 		nameServicePort = nameServicePort == null || nameServicePort.isEmpty() ? String.valueOf(2809) : nameServicePort;
 		if (nameServicePort == null || nameServicePort.isEmpty()) {
 			throw new IllegalArgumentException("name service port is unknown: define system property 'port'");
 		}

 		if (serviceName == null || serviceName.isEmpty()) {
 			throw new IllegalArgumentException("service name is unknown: define system property 'service'");
 		}

 		Map<String, String> connectionParameters = new HashMap<>();
 		connectionParameters.put(PARAM_NAMESERVICE, String.format(NAME_SERVICE, nameServiceHost, nameServicePort));
 		connectionParameters.put(PARAM_SERVICENAME, serviceName + ".ASAM-ODS");
 		connectionParameters.put(PARAM_USER, USER);
 		connectionParameters.put(PARAM_PASSWORD, PASSWORD);

 		context = new ODSContextFactory().connect(connectionParameters);
 	}

 	@AfterClass
 	public static void tearDownAfterClass() throws ConnectionException {
 		if (context != null) {
 			context.close();
 		}

 	}

 	private NodeProviderRoot getNodeProviderRoot() {
 		NodeLevel nl = createStructure(context, ContextState.MEASURED);
 		NodeProviderRoot npr = new NodeProviderRoot();
 		npr.setId("generic_measured");
 		npr.setName("Measured");
 		npr.setContexts(ImmutableMap.of("*", nl));

 		return npr;
 	}

 	private GenericNodeProvider getGenericNodeProvider(NodeProviderRoot npr) {
 		ConnectorService connectorService = Mockito.mock(ConnectorService.class);
 		Mockito.when(connectorService.getContexts()).thenReturn(Arrays.asList(context));
 		Mockito.when(connectorService.getContextByName(any())).thenReturn(context);

 		return new GenericNodeProvider(connectorService, npr);
 	}

 	@Test
 	public void testGetRoots() {
 		GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());

 		assertThat(np.getRoots())
 				.containsExactly(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"));
 	}

 	@Test
 	public void testGetChildren() {
 		GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());

 		List<Node> roots = np.getRoots();

 		List<Node> projects = np.getChildren(roots.get(0));
 		assertThat(projects).containsExactly(
 				SerializationUtil.createNode("NVHDEMO", "Project", "5", "Id", "Project.Id eq \"5\"", "PMV 2PV"),
 				SerializationUtil.createNode("NVHDEMO", "Project", "4", "Id", "Project.Id eq \"4\"", "PMV Model P"),
 				SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "Project.Id eq \"3\"", "PMV Summit"));

 		List<Node> vehicleTypes = np.getChildren(findNodeWithLabel(projects, "PMV Summit"));
 		assertThat(vehicleTypes).containsExactly(
 				SerializationUtil.createNode("NVHDEMO", "vehicle", "Model P", "model",
 						"Project.Id eq \"3\" and vehicle.model eq \"Model P\"", "Model P"),
 				SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model",
 						"Project.Id eq \"3\" and vehicle.model eq \"Summit\"", "Summit"));

 		List<Node> tests = np.getChildren(findNodeWithLabel(vehicleTypes, "Summit"));
 		assertThat(tests).containsExactly(SerializationUtil.createNode("NVHDEMO", "Test", "4", "Id",
 				"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\"",
 				"PBN_UNECE_R51_20140213130501"));

 		List<Node> testSteps = np.getChildren(findNodeWithLabel(tests, "PBN_UNECE_R51_20140213130501"));
 		assertThat(testSteps).containsExactly(SerializationUtil.createNode("NVHDEMO", "TestStep", "11", "Id",
 				"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\"",
 				"PBN_UNECE_R51_Left_Acc_50"),
 				SerializationUtil.createNode("NVHDEMO", "TestStep", "10", "Id",
 						"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"10\"",
 						"PBN_UNECE_R51_Left_Steady_50"),
 				SerializationUtil.createNode("NVHDEMO", "TestStep", "13", "Id",
 						"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"13\"",
 						"PBN_UNECE_R51_Right_Acc_50"),
 				SerializationUtil.createNode("NVHDEMO", "TestStep", "12", "Id",
 						"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"12\"",
 						"PBN_UNECE_R51_Right_Steady_50"));

 		List<Node> measurements = np.getChildren(findNodeWithLabel(testSteps, "PBN_UNECE_R51_Left_Acc_50"));
 		assertThat(measurements).containsExactly(SerializationUtil.createNode("NVHDEMO", "Measurement", "175", "Id",
 				"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\" and Measurement.Id eq \"175\"",
 				"Channel"),
 				SerializationUtil.createNode("NVHDEMO", "Measurement", "176", "Id",
 						"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\" and Measurement.Id eq \"176\"",
 						"Document"),
 				SerializationUtil.createNode("NVHDEMO", "Measurement", "177", "Id",
 						"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\" and Measurement.Id eq \"177\"",
 						"Photo"));

 		List<Node> channelGroups = np.getChildren(findNodeWithLabel(measurements, "Channel"));
 		assertThat(channelGroups).containsExactly(SerializationUtil.createNode("NVHDEMO", "ChannelGroup", "2011", "Id",
 				"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\" and Measurement.Id eq \"175\" and ChannelGroup.Id eq \"2011\"",
 				"Channel"));

 		List<Node> channels = np.getChildren(findNodeWithLabel(channelGroups, "Channel"));
 		assertThat(channels).hasSize(11).startsWith(SerializationUtil.createNode("NVHDEMO", "Channel", "8498", "Id",
 				"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\" and Measurement.Id eq \"175\" and ChannelGroup.Id eq \"2011\" and Channel.Id eq \"8498\"",
 				"CHANNEL01"));
 	}

 	private Node findNodeWithLabel(List<Node> nodes, String label) {
 		return nodes.stream().filter(n -> n.getLabel().equals(label)).findFirst().orElseThrow(
 				() -> new AssertionFailedError("Node node with label " + label + " found in " + nodes + "."));
 	}

 	@Test
 	public void testGetParentNodeEnvironment() {
 		NodeProviderRoot npr = getNodeProviderRoot();
 		GenericNodeProvider np = getGenericNodeProvider(npr);

 		NodeLevel nlEnvironment = npr.getNodeLevel(context, "Environment", null);

 		assertThat(np.loadParentNode(context,
 				SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"), nlEnvironment))
 						.isNull();
 	}

 	@Test
 	public void testGetParentNodeProject() {
 		NodeProviderRoot npr = getNodeProviderRoot();
 		GenericNodeProvider np = getGenericNodeProvider(npr);

 		NodeLevel nlProject = npr.getNodeLevel(context, "Project", null);

 		assertThat(
 				np.loadParentNode(context,
 						SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "Project.Id eq \"3\"",
 								"PMV Summit"),
 						nlProject))
 								.isEqualTo(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id",
 										"Project.Id eq \"3\"", "MDM-NVH"));
 	}

 	@Test
 	public void testGetParentNodeVehicle() {
 		NodeProviderRoot npr = getNodeProviderRoot();
 		GenericNodeProvider np = getGenericNodeProvider(npr);

 		NodeLevel nlVehicle = npr.getNodeLevel(context, "vehicle", "model");

 		assertThat(np.loadParentNode(context,
 				SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model", "vehicle.model eq \"Summit\"",
 						"Summit"),
 				nlVehicle))
 						.isEqualTo(SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id",
 								"vehicle.model eq \"Summit\" and Project.Id eq \"3\"", "PMV Summit"));
 	}

 	@Test
 	public void testGetParentNodeTest() {
 		NodeProviderRoot npr = getNodeProviderRoot();
 		GenericNodeProvider np = getGenericNodeProvider(npr);

 		NodeLevel nlTest = npr.getNodeLevel(context, "Test", null);

 		assertThat(np.loadParentNode(context,
 				SerializationUtil.createNode("NVHDEMO", "Test", "4", "Id", "Test.Id eq \"4\"", ""), nlTest))
 						.isEqualTo(SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model",
 								"Test.Id eq \"4\" and vehicle.model eq \"Summit\"", "Summit"));
 	}

 	@Test
 	public void testGetParentNodeTestStep() {
 		NodeProviderRoot npr = getNodeProviderRoot();
 		GenericNodeProvider np = getGenericNodeProvider(npr);

 		NodeLevel nlTestStep = npr.getNodeLevel(context, "TestStep", null);

 		assertThat(np.loadParentNode(context,
 				SerializationUtil.createNode("NVHDEMO", "TestStep", "11", "Id", "TestStep.Id eq \"11\"", ""),
 				nlTestStep))
 						.isEqualTo(SerializationUtil.createNode("NVHDEMO", "Test", "4", "Id",
 								"TestStep.Id eq \"11\" and Test.Id eq \"4\"", "PBN_UNECE_R51_20140213130501"));
 	}

 	@Test
 	public void testGetTreePathEnvironment() {
 		GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());
 		assertThat(np.getTreePath(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH")))
 				.containsExactly(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"));
 	}

 	@Test
 	public void testGetTreePathProject() {
 		GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());
 		assertThat(np.getTreePath(SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "", "PMV Summit")))
 				.containsExactly(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"),
 						SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "Project.Id eq \"3\"",
 								"PMV Summit"));
 	}

 	@Test
 	public void testGetTreePathVehicle() {
 		GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());
 		assertThat(np.getTreePath(SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model", "", "Summit")))
 				.containsExactly(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"),
 						SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "Project.Id eq \"3\"",
 								"PMV Summit"),
 						SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model",
 								"Project.Id eq \"3\" and vehicle.model eq \"Summit\"", "Summit"));
 	}

 	@Test
 	public void testGetTreePathTest() {
 		GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());
 		assertThat(np.getTreePath(SerializationUtil.createNode("NVHDEMO", "Test", "4", "", "", ""))).containsExactly(
 				SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"),
 				SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "Project.Id eq \"3\"", "PMV Summit"),
 				SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model",
 						"Project.Id eq \"3\" and vehicle.model eq \"Summit\"", "Summit"),
 				SerializationUtil.createNode("NVHDEMO", "Test", "4", "Id",
 						"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\"",
 						"PBN_UNECE_R51_20140213130501"));
 	}

 	@Test
 	public void testGetTreePathTestStep() {
 		GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());
 		assertThat(np.getTreePath(SerializationUtil.createNode("NVHDEMO", "TestStep", "11", "Id", "", "Name")))
 				.containsExactly(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"),
 						SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "Project.Id eq \"3\"",
 								"PMV Summit"),
 						SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model",
 								"Project.Id eq \"3\" and vehicle.model eq \"Summit\"", "Summit"),
 						SerializationUtil.createNode("NVHDEMO", "Test", "4", "Id",
 								"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\"",
 								"PBN_UNECE_R51_20140213130501"),
 						SerializationUtil.createNode("NVHDEMO", "TestStep", "11", "Id",
 								"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\"",
 								"PBN_UNECE_R51_Left_Acc_50"));
 	}

 	private static NodeLevel createStructure(ApplicationContext context, ContextState contextState) {
 		ModelManager modelManager = context.getModelManager().get();

 		EntityType etEnv = modelManager.getEntityType(Environment.class);
 		NodeLevel env = new NodeLevel(etEnv);
 		env.getOrderAttributes().add(new SortAttribute(env.getLabelAttribute()));

 		NodeLevel project = new NodeLevel(modelManager.getEntityType(Project.class));
 		project.getOrderAttributes().add(new SortAttribute(project.getLabelAttribute()));

 		EntityType vehicle = modelManager.getEntityType("vehicle");
 		NodeLevel vehicleModel = new NodeLevel(vehicle, vehicle.getAttribute("model"), vehicle.getAttribute("model"));
 		vehicleModel.setVirtual(true);
 		vehicleModel.setContextState(contextState);
 		vehicleModel.getOrderAttributes().add(new SortAttribute(vehicleModel.getLabelAttribute()));

 		NodeLevel test = new NodeLevel(modelManager.getEntityType(org.eclipse.mdm.api.base.model.Test.class));
 		test.getOrderAttributes().add(new SortAttribute(test.getLabelAttribute()));

 		NodeLevel testStep = new NodeLevel(modelManager.getEntityType(TestStep.class));
 		testStep.getOrderAttributes().add(new SortAttribute(testStep.getLabelAttribute()));

 		NodeLevel measurement = new NodeLevel(modelManager.getEntityType(Measurement.class));
 		measurement.getOrderAttributes().add(new SortAttribute(measurement.getLabelAttribute()));

 		NodeLevel channelGroup = new NodeLevel(modelManager.getEntityType(ChannelGroup.class));
 		channelGroup.getOrderAttributes().add(new SortAttribute(channelGroup.getLabelAttribute()));

 		NodeLevel channel = new NodeLevel(modelManager.getEntityType(Channel.class));
 		channel.getOrderAttributes().add(new SortAttribute(channel.getLabelAttribute()));

 		env.setChild(project);
 		project.setChild(vehicleModel);
 		vehicleModel.setChild(test);
 		test.setChild(testStep);
 		testStep.setChild(measurement);
 		measurement.setChild(channelGroup);
 		channelGroup.setChild(channel);

 		return env;
 	}
 }
	package org.eclipse.mdm.nodeprovider.control;

	import static org.assertj.core.api.Assertions.assertThat;
	import static org.eclipse.mdm.api.odsadapter.ODSContextFactory.PARAM_NAMESERVICE;
	import static org.eclipse.mdm.api.odsadapter.ODSContextFactory.PARAM_PASSWORD;
	import static org.eclipse.mdm.api.odsadapter.ODSContextFactory.PARAM_SERVICENAME;
	import static org.eclipse.mdm.api.odsadapter.ODSContextFactory.PARAM_USER;
	import static org.mockito.ArgumentMatchers.any;

	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.mdm.api.base.ConnectionException;
	import org.eclipse.mdm.api.base.adapter.EntityType;
	import org.eclipse.mdm.api.base.adapter.ModelManager;
	import org.eclipse.mdm.api.base.model.Channel;
	import org.eclipse.mdm.api.base.model.ChannelGroup;
	import org.eclipse.mdm.api.base.model.Environment;
	import org.eclipse.mdm.api.base.model.Measurement;
	import org.eclipse.mdm.api.base.model.TestStep;
	import org.eclipse.mdm.api.base.search.ContextState;
	import org.eclipse.mdm.api.dflt.ApplicationContext;
	import org.eclipse.mdm.api.dflt.model.Project;
	import org.eclipse.mdm.api.odsadapter.ODSContextFactory;
	import org.eclipse.mdm.connector.boundary.ConnectorService;
	import org.eclipse.mdm.nodeprovider.entity.NodeLevel;
	import org.eclipse.mdm.nodeprovider.entity.NodeProviderRoot;
	import org.eclipse.mdm.nodeprovider.entity.SortAttribute;
	import org.eclipse.mdm.nodeprovider.utils.SerializationUtil;
	import org.eclipse.mdm.protobuf.Mdm.Node;
	import org.junit.AfterClass;
	import org.junit.BeforeClass;
	import org.junit.Ignore;
	import org.junit.Test;
	import org.mockito.Mockito;

	import com.google.common.collect.ImmutableMap;

	import junit.framework.AssertionFailedError;

	@Ignore
	//FIXME 25.11.2020: this test needs a running ODS Server, that is not suitable for continous build in Jenkins.
	//Comment this in for local tests only.
	public class GenericNodeProviderTest {
	/*
	* ATTENTION: ==========
	*
	* To run this test make sure the target service is running a MDM default model
	* and any database constraint which enforces a relation of Test to a parent
	* entity is deactivated!
	*/

	private static final String NAME_SERVICE = "corbaloc::1.2@%s:%s/NameService";

	private static final String USER = "sa";
	private static final String PASSWORD = "sa";

	private static ApplicationContext context;

	@BeforeClass
	public static void setUpBeforeClass() throws ConnectionException {
	String nameServiceHost = System.getProperty("host");
	String nameServicePort = System.getProperty("port");
	String serviceName = System.getProperty("service");

	if (nameServiceHost == null \|\| nameServiceHost.isEmpty()) {
	throw new IllegalArgumentException("name service host is unknown: define system property 'host'");
	}

	nameServicePort = nameServicePort == null \|\| nameServicePort.isEmpty() ? String.valueOf(2809) : nameServicePort;
	if (nameServicePort == null \|\| nameServicePort.isEmpty()) {
	throw new IllegalArgumentException("name service port is unknown: define system property 'port'");
	}

	if (serviceName == null \|\| serviceName.isEmpty()) {
	throw new IllegalArgumentException("service name is unknown: define system property 'service'");
	}

	Map<String, String> connectionParameters = new HashMap<>();
	connectionParameters.put(PARAM_NAMESERVICE, String.format(NAME_SERVICE, nameServiceHost, nameServicePort));
	connectionParameters.put(PARAM_SERVICENAME, serviceName + ".ASAM-ODS");
	connectionParameters.put(PARAM_USER, USER);
	connectionParameters.put(PARAM_PASSWORD, PASSWORD);

	context = new ODSContextFactory().connect(connectionParameters);
	}

	@AfterClass
	public static void tearDownAfterClass() throws ConnectionException {
	if (context != null) {
	context.close();
	}

	}

	private NodeProviderRoot getNodeProviderRoot() {
	NodeLevel nl = createStructure(context, ContextState.MEASURED);
	NodeProviderRoot npr = new NodeProviderRoot();
	npr.setId("generic_measured");
	npr.setName("Measured");
	npr.setContexts(ImmutableMap.of("*", nl));

	return npr;
	}

	private GenericNodeProvider getGenericNodeProvider(NodeProviderRoot npr) {
	ConnectorService connectorService = Mockito.mock(ConnectorService.class);
	Mockito.when(connectorService.getContexts()).thenReturn(Arrays.asList(context));
	Mockito.when(connectorService.getContextByName(any())).thenReturn(context);

	return new GenericNodeProvider(connectorService, npr);
	}

	@Test
	public void testGetRoots() {
	GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());

	assertThat(np.getRoots())
	.containsExactly(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"));
	}

	@Test
	public void testGetChildren() {
	GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());

	List<Node> roots = np.getRoots();

	List<Node> projects = np.getChildren(roots.get(0));
	assertThat(projects).containsExactly(
	SerializationUtil.createNode("NVHDEMO", "Project", "5", "Id", "Project.Id eq \"5\"", "PMV 2PV"),
	SerializationUtil.createNode("NVHDEMO", "Project", "4", "Id", "Project.Id eq \"4\"", "PMV Model P"),
	SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "Project.Id eq \"3\"", "PMV Summit"));

	List<Node> vehicleTypes = np.getChildren(findNodeWithLabel(projects, "PMV Summit"));
	assertThat(vehicleTypes).containsExactly(
	SerializationUtil.createNode("NVHDEMO", "vehicle", "Model P", "model",
	"Project.Id eq \"3\" and vehicle.model eq \"Model P\"", "Model P"),
	SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\"", "Summit"));

	List<Node> tests = np.getChildren(findNodeWithLabel(vehicleTypes, "Summit"));
	assertThat(tests).containsExactly(SerializationUtil.createNode("NVHDEMO", "Test", "4", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\"",
	"PBN_UNECE_R51_20140213130501"));

	List<Node> testSteps = np.getChildren(findNodeWithLabel(tests, "PBN_UNECE_R51_20140213130501"));
	assertThat(testSteps).containsExactly(SerializationUtil.createNode("NVHDEMO", "TestStep", "11", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\"",
	"PBN_UNECE_R51_Left_Acc_50"),
	SerializationUtil.createNode("NVHDEMO", "TestStep", "10", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"10\"",
	"PBN_UNECE_R51_Left_Steady_50"),
	SerializationUtil.createNode("NVHDEMO", "TestStep", "13", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"13\"",
	"PBN_UNECE_R51_Right_Acc_50"),
	SerializationUtil.createNode("NVHDEMO", "TestStep", "12", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"12\"",
	"PBN_UNECE_R51_Right_Steady_50"));

	List<Node> measurements = np.getChildren(findNodeWithLabel(testSteps, "PBN_UNECE_R51_Left_Acc_50"));
	assertThat(measurements).containsExactly(SerializationUtil.createNode("NVHDEMO", "Measurement", "175", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\" and Measurement.Id eq \"175\"",
	"Channel"),
	SerializationUtil.createNode("NVHDEMO", "Measurement", "176", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\" and Measurement.Id eq \"176\"",
	"Document"),
	SerializationUtil.createNode("NVHDEMO", "Measurement", "177", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\" and Measurement.Id eq \"177\"",
	"Photo"));

	List<Node> channelGroups = np.getChildren(findNodeWithLabel(measurements, "Channel"));
	assertThat(channelGroups).containsExactly(SerializationUtil.createNode("NVHDEMO", "ChannelGroup", "2011", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\" and Measurement.Id eq \"175\" and ChannelGroup.Id eq \"2011\"",
	"Channel"));

	List<Node> channels = np.getChildren(findNodeWithLabel(channelGroups, "Channel"));
	assertThat(channels).hasSize(11).startsWith(SerializationUtil.createNode("NVHDEMO", "Channel", "8498", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\" and Measurement.Id eq \"175\" and ChannelGroup.Id eq \"2011\" and Channel.Id eq \"8498\"",
	"CHANNEL01"));
	}

	private Node findNodeWithLabel(List<Node> nodes, String label) {
	return nodes.stream().filter(n -> n.getLabel().equals(label)).findFirst().orElseThrow(
	() -> new AssertionFailedError("Node node with label " + label + " found in " + nodes + "."));
	}

	@Test
	public void testGetParentNodeEnvironment() {
	NodeProviderRoot npr = getNodeProviderRoot();
	GenericNodeProvider np = getGenericNodeProvider(npr);

	NodeLevel nlEnvironment = npr.getNodeLevel(context, "Environment", null);

	assertThat(np.loadParentNode(context,
	SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"), nlEnvironment))
	.isNull();
	}

	@Test
	public void testGetParentNodeProject() {
	NodeProviderRoot npr = getNodeProviderRoot();
	GenericNodeProvider np = getGenericNodeProvider(npr);

	NodeLevel nlProject = npr.getNodeLevel(context, "Project", null);

	assertThat(
	np.loadParentNode(context,
	SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "Project.Id eq \"3\"",
	"PMV Summit"),
	nlProject))
	.isEqualTo(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id",
	"Project.Id eq \"3\"", "MDM-NVH"));
	}

	@Test
	public void testGetParentNodeVehicle() {
	NodeProviderRoot npr = getNodeProviderRoot();
	GenericNodeProvider np = getGenericNodeProvider(npr);

	NodeLevel nlVehicle = npr.getNodeLevel(context, "vehicle", "model");

	assertThat(np.loadParentNode(context,
	SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model", "vehicle.model eq \"Summit\"",
	"Summit"),
	nlVehicle))
	.isEqualTo(SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id",
	"vehicle.model eq \"Summit\" and Project.Id eq \"3\"", "PMV Summit"));
	}

	@Test
	public void testGetParentNodeTest() {
	NodeProviderRoot npr = getNodeProviderRoot();
	GenericNodeProvider np = getGenericNodeProvider(npr);

	NodeLevel nlTest = npr.getNodeLevel(context, "Test", null);

	assertThat(np.loadParentNode(context,
	SerializationUtil.createNode("NVHDEMO", "Test", "4", "Id", "Test.Id eq \"4\"", ""), nlTest))
	.isEqualTo(SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model",
	"Test.Id eq \"4\" and vehicle.model eq \"Summit\"", "Summit"));
	}

	@Test
	public void testGetParentNodeTestStep() {
	NodeProviderRoot npr = getNodeProviderRoot();
	GenericNodeProvider np = getGenericNodeProvider(npr);

	NodeLevel nlTestStep = npr.getNodeLevel(context, "TestStep", null);

	assertThat(np.loadParentNode(context,
	SerializationUtil.createNode("NVHDEMO", "TestStep", "11", "Id", "TestStep.Id eq \"11\"", ""),
	nlTestStep))
	.isEqualTo(SerializationUtil.createNode("NVHDEMO", "Test", "4", "Id",
	"TestStep.Id eq \"11\" and Test.Id eq \"4\"", "PBN_UNECE_R51_20140213130501"));
	}

	@Test
	public void testGetTreePathEnvironment() {
	GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());
	assertThat(np.getTreePath(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH")))
	.containsExactly(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"));
	}

	@Test
	public void testGetTreePathProject() {
	GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());
	assertThat(np.getTreePath(SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "", "PMV Summit")))
	.containsExactly(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"),
	SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "Project.Id eq \"3\"",
	"PMV Summit"));
	}

	@Test
	public void testGetTreePathVehicle() {
	GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());
	assertThat(np.getTreePath(SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model", "", "Summit")))
	.containsExactly(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"),
	SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "Project.Id eq \"3\"",
	"PMV Summit"),
	SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\"", "Summit"));
	}

	@Test
	public void testGetTreePathTest() {
	GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());
	assertThat(np.getTreePath(SerializationUtil.createNode("NVHDEMO", "Test", "4", "", "", ""))).containsExactly(
	SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"),
	SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "Project.Id eq \"3\"", "PMV Summit"),
	SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\"", "Summit"),
	SerializationUtil.createNode("NVHDEMO", "Test", "4", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\"",
	"PBN_UNECE_R51_20140213130501"));
	}

	@Test
	public void testGetTreePathTestStep() {
	GenericNodeProvider np = getGenericNodeProvider(getNodeProviderRoot());
	assertThat(np.getTreePath(SerializationUtil.createNode("NVHDEMO", "TestStep", "11", "Id", "", "Name")))
	.containsExactly(SerializationUtil.createNode("NVHDEMO", "Environment", "1", "Id", "", "MDM-NVH"),
	SerializationUtil.createNode("NVHDEMO", "Project", "3", "Id", "Project.Id eq \"3\"",
	"PMV Summit"),
	SerializationUtil.createNode("NVHDEMO", "vehicle", "Summit", "model",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\"", "Summit"),
	SerializationUtil.createNode("NVHDEMO", "Test", "4", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\"",
	"PBN_UNECE_R51_20140213130501"),
	SerializationUtil.createNode("NVHDEMO", "TestStep", "11", "Id",
	"Project.Id eq \"3\" and vehicle.model eq \"Summit\" and Test.Id eq \"4\" and TestStep.Id eq \"11\"",
	"PBN_UNECE_R51_Left_Acc_50"));
	}

	private static NodeLevel createStructure(ApplicationContext context, ContextState contextState) {
	ModelManager modelManager = context.getModelManager().get();

	EntityType etEnv = modelManager.getEntityType(Environment.class);
	NodeLevel env = new NodeLevel(etEnv);
	env.getOrderAttributes().add(new SortAttribute(env.getLabelAttribute()));

	NodeLevel project = new NodeLevel(modelManager.getEntityType(Project.class));
	project.getOrderAttributes().add(new SortAttribute(project.getLabelAttribute()));

	EntityType vehicle = modelManager.getEntityType("vehicle");
	NodeLevel vehicleModel = new NodeLevel(vehicle, vehicle.getAttribute("model"), vehicle.getAttribute("model"));
	vehicleModel.setVirtual(true);
	vehicleModel.setContextState(contextState);
	vehicleModel.getOrderAttributes().add(new SortAttribute(vehicleModel.getLabelAttribute()));

	NodeLevel test = new NodeLevel(modelManager.getEntityType(org.eclipse.mdm.api.base.model.Test.class));
	test.getOrderAttributes().add(new SortAttribute(test.getLabelAttribute()));

	NodeLevel testStep = new NodeLevel(modelManager.getEntityType(TestStep.class));
	testStep.getOrderAttributes().add(new SortAttribute(testStep.getLabelAttribute()));

	NodeLevel measurement = new NodeLevel(modelManager.getEntityType(Measurement.class));
	measurement.getOrderAttributes().add(new SortAttribute(measurement.getLabelAttribute()));

	NodeLevel channelGroup = new NodeLevel(modelManager.getEntityType(ChannelGroup.class));
	channelGroup.getOrderAttributes().add(new SortAttribute(channelGroup.getLabelAttribute()));

	NodeLevel channel = new NodeLevel(modelManager.getEntityType(Channel.class));
	channel.getOrderAttributes().add(new SortAttribute(channel.getLabelAttribute()));

	env.setChild(project);
	project.setChild(vehicleModel);
	vehicleModel.setChild(test);
	test.setChild(testStep);
	testStep.setChild(measurement);
	measurement.setChild(channelGroup);
	channelGroup.setChild(channel);

	return env;
	}
	}