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

 /*******************************************************************************
  *  Copyright (c) 2021 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.nodeprovider.control;

 import static java.util.stream.Collectors.toList;
 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);

 		MDMExpressionLanguageService elService = Mockito.mock(MDMExpressionLanguageService.class);

 		return new GenericNodeProvider(connectorService, npr, elService);
 	}

 	@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().addAll(env.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

 		NodeLevel project = new NodeLevel(modelManager.getEntityType(Project.class));
 		project.getOrderAttributes().addAll(project.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

 		EntityType vehicle = modelManager.getEntityType("vehicle");
 		NodeLevel vehicleModel = new NodeLevel(vehicle, vehicle.getAttribute("model"), vehicle.getAttribute("model"));
 		vehicleModel.setVirtual(true);
 		vehicleModel.setContextState(contextState);
 		vehicleModel.getOrderAttributes().addAll(vehicleModel.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

 		NodeLevel test = new NodeLevel(modelManager.getEntityType(org.eclipse.mdm.api.base.model.Test.class));
 		test.getOrderAttributes().addAll(test.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

 		NodeLevel testStep = new NodeLevel(modelManager.getEntityType(TestStep.class));
 		testStep.getOrderAttributes().addAll(testStep.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

 		NodeLevel measurement = new NodeLevel(modelManager.getEntityType(Measurement.class));
 		measurement.getOrderAttributes().addAll(measurement.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

 		NodeLevel channelGroup = new NodeLevel(modelManager.getEntityType(ChannelGroup.class));
 		channelGroup.getOrderAttributes().addAll(channelGroup.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

 		NodeLevel channel = new NodeLevel(modelManager.getEntityType(Channel.class));
 		channel.getOrderAttributes().addAll(channel.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

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

 		return env;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2021 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.nodeprovider.control;

	import static java.util.stream.Collectors.toList;
	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);

	MDMExpressionLanguageService elService = Mockito.mock(MDMExpressionLanguageService.class);

	return new GenericNodeProvider(connectorService, npr, elService);
	}

	@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().addAll(env.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

	NodeLevel project = new NodeLevel(modelManager.getEntityType(Project.class));
	project.getOrderAttributes().addAll(project.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

	EntityType vehicle = modelManager.getEntityType("vehicle");
	NodeLevel vehicleModel = new NodeLevel(vehicle, vehicle.getAttribute("model"), vehicle.getAttribute("model"));
	vehicleModel.setVirtual(true);
	vehicleModel.setContextState(contextState);
	vehicleModel.getOrderAttributes().addAll(vehicleModel.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

	NodeLevel test = new NodeLevel(modelManager.getEntityType(org.eclipse.mdm.api.base.model.Test.class));
	test.getOrderAttributes().addAll(test.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

	NodeLevel testStep = new NodeLevel(modelManager.getEntityType(TestStep.class));
	testStep.getOrderAttributes().addAll(testStep.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

	NodeLevel measurement = new NodeLevel(modelManager.getEntityType(Measurement.class));
	measurement.getOrderAttributes().addAll(measurement.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

	NodeLevel channelGroup = new NodeLevel(modelManager.getEntityType(ChannelGroup.class));
	channelGroup.getOrderAttributes().addAll(channelGroup.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

	NodeLevel channel = new NodeLevel(modelManager.getEntityType(Channel.class));
	channel.getOrderAttributes().addAll(channel.getLabelAttributes().stream().map(SortAttribute::new).collect(toList()));

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

	return env;
	}
	}