nucleus/businessobjects/src/test/java/org/eclipse/mdm/nodeprovider/boundary/NodeProviderServiceTest.java

/********************************************************************************
 * Copyright (c) 2015-2020 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.boundary;

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 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.Attribute;
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.query.ComparisonOperator;
import org.eclipse.mdm.api.base.query.Filter;
import org.eclipse.mdm.api.base.search.ContextState;
import org.eclipse.mdm.api.dflt.ApplicationContext;
import org.eclipse.mdm.api.dflt.model.Pool;
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.Node;
import org.eclipse.mdm.nodeprovider.entity.NodeLevel;
import org.eclipse.mdm.nodeprovider.entity.NodeProvider;
import org.eclipse.mdm.nodeprovider.entity.NodeProviderRoot;
import org.eclipse.mdm.nodeprovider.utils.SerializationUtil;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.Mockito;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.collect.ImmutableMap;

@Ignore
//FIXME 15.07.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 NodeProviderServiceTest {

	/*
	 * 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 Logger LOGGER = LoggerFactory.getLogger(NodeProviderServiceTest.class);

	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;
	private static ApplicationContext context2;

	@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);

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

		context2 = new ODSContextFactory().connect(connectionParameters2);
	}

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

		if (context2 != null) {
			context2.close();
		}
	}

//	@Test
//	public void testJson() throws IOException {
//		ConnectorService connectorService = Mockito.mock(ConnectorService.class);
//		Mockito.when(connectorService.getContexts()).thenReturn(Arrays.asList(context, context2));
//
//		GenericNodeProvider np = new GenericNodeProvider(connectorService, ContextState.MEASURED);
//
//		NodeProviderRoot npr = new NodeProviderRoot();
//		npr.setId("generic_measured");
//		npr.setName("Generic Measured");
//		npr.getContexts().put("*", np.createStructure(context, ContextState.MEASURED));
//
//		String json = NodeLevelUtil.serialize(npr);
//
//		System.out.println(json);
//
//		NodeProviderRoot readNpr = NodeLevelUtil.deserialize(connectorService, json);
//
//		System.out.println(readNpr);
//	}

	@Test
	public void testRoot() {
		ModelManager mm = context.getModelManager().get();
		EntityType project = mm.getEntityType("Project");
		EntityType vehicle = mm.getEntityType("vehicle");
		Attribute model = vehicle.getAttribute("model");
		EntityType test = mm.getEntityType("Test");

		ConnectorService connectorService = Mockito.mock(ConnectorService.class);
		Mockito.when(connectorService.getContexts()).thenReturn(Arrays.asList(context, context2));

		NodeProviderService repo = new NodeProviderService(connectorService);
		NodeProvider nodeProvider = repo.getNodeProvider("generic");

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

		assertThat(roots).containsExactly(new Node("NVHDEMO", "Environment", "1", "Id", Filter.and(), "MDM-NVH"));

		List<Node> level1 = nodeProvider
				.getChildren(roots.stream().filter(n -> "MDM-NVH".equals(n.getLabel())).findFirst().get());

		assertThat(level1).containsExactly(
				new Node("NVHDEMO", "Project", "1", "Id", Filter.and().id(project, "5"), "PMV 2PV"),
				new Node("NVHDEMO", "Project", "2", "Id", Filter.and().id(project, "4"), "PMV Model P"),
				new Node("NVHDEMO", "Project", "3", "Id", Filter.and().id(project, "3"), "PMV Summit"));

		List<Node> level2 = nodeProvider.getChildren(getNodeWithLabel(level1, "PMV Summit"));

		assertThat(level2).containsExactly(new Node("NVHDEMO", "vehicle", "NO_ID", "Id",
				Filter.and().id(project, "3").add(ComparisonOperator.EQUAL.create(model, "Model P")), "Model P"),
				new Node("NVHDEMO", "vehicle", "NO_ID", "Id",
						Filter.and().id(project, "3").add(ComparisonOperator.EQUAL.create(model, "Summit")), "Summit"));

		List<Node> level3 = nodeProvider.getChildren(getNodeWithLabel(level2, "Model P"));

		System.out.println(level3);

		Filter parent = Filter.and().id(project, "3").add(ComparisonOperator.EQUAL.create(model, "Model P"));

		assertThat(level3).isEmpty();

		level3 = nodeProvider.getChildren(getNodeWithLabel(level2, "Summit"));

		System.out.println(level3);

		parent = Filter.and().id(project, "3").add(ComparisonOperator.EQUAL.create(model, "Summit"));

		assertThat(level3).containsExactly(
				new Node("NVHDEMO", "Test", "1", "Id", parent.copy().id(test, "4"), "PBN_UNECE_R51_20140213130501"));
	}

	@Test
	public void testTests() {
		ModelManager mm = context.getModelManager().get();
		EntityType project = mm.getEntityType("Project");
		EntityType vehicle = mm.getEntityType("vehicle");
		Attribute model = vehicle.getAttribute("model");
		EntityType test = mm.getEntityType("Test");

		ConnectorService connectorService = Mockito.mock(ConnectorService.class);
		Mockito.when(connectorService.getContexts()).thenReturn(Arrays.asList(context));

		NodeProviderService repo = new NodeProviderService(connectorService);
		NodeProvider nodeProvider = repo.getNodeProvider("generic");

		List<Node> envs = nodeProvider.getRoots();
		List<Node> projects = nodeProvider.getChildren(envs.get(0));
		List<Node> vehicleModels = nodeProvider.getChildren(getNodeWithLabel(projects, "PMV Summit"));
		List<Node> tests = nodeProvider.getChildren(getNodeWithLabel(vehicleModels, "Summit"));

		System.out.println(tests);

		Filter parent = Filter.and().id(project, "3").add(ComparisonOperator.EQUAL.create(model, "Summit"));

		assertThat(tests).containsExactly(new Node("NVHDEMO", "Test", "1", "Id", parent.copy().id(test, "4"),
				"PBN_UNECE_R51_20140213130501")/*
												 * , new Node("NVHDEMO", "Test", "2",
												 * parent.copy().id(ContextState.ORDERED, test, "13"),
												 * "PBN_UNECE_R51_20140314170907")
												 */);
	}

	@Test
	public void testTests2() {
		ModelManager mm = context.getModelManager().get();
		EntityType project = mm.getEntityType("Project");
		EntityType vehicle = mm.getEntityType("vehicle");
		Attribute model = vehicle.getAttribute("model");
		EntityType test = mm.getEntityType("Test");

		ConnectorService connectorService = Mockito.mock(ConnectorService.class);
		Mockito.when(connectorService.getContexts()).thenReturn(Arrays.asList(context));

		NodeProviderService repo = new NodeProviderService(connectorService);
		NodeProvider nodeProvider = repo.getNodeProvider("generic");

		List<Node> envs = nodeProvider.getRoots();
		List<Node> projects = nodeProvider.getChildren(envs.get(0));
		List<Node> vehicleModels = nodeProvider.getChildren(getNodeWithLabel(projects, "PMV Model P"));
		List<Node> tests = nodeProvider.getChildren(getNodeWithLabel(vehicleModels, "Model P"));

		System.out.println(tests);

		Filter parent = Filter.and().id(project, "4").add(ComparisonOperator.EQUAL.create(model, "Model P"));

		assertThat(tests).containsExactly(
				new Node("NVHDEMO", "Test", "1", "Id", parent.copy().id(test, "13"), "PBN_UNECE_R51_20140314170907"));
	}

	private Node getNodeWithLabel(List<Node> nodes, String label) {
		return nodes.stream().filter(p -> label.equalsIgnoreCase(p.getLabel())).findAny().get();
	}

	@Test
	public void test() {
		NodeLevel nl = createStructure(context, ContextState.MEASURED);
		NodeProviderRoot npr = new NodeProviderRoot();
		npr.setId("generic_measured");
		npr.setName("Measured");
		npr.setContexts(ImmutableMap.of("*", nl));

		System.out.println(SerializationUtil.serializeNodeProviderRoot(npr));
	}

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

		NodeLevel env = new NodeLevel(modelManager.getEntityType(Environment.class));
		NodeLevel project = new NodeLevel(modelManager.getEntityType(Project.class));
		EntityType vehicle = modelManager.getEntityType("vehicle");

		NodeLevel vehicleModel = new NodeLevel(vehicle, vehicle.getAttribute("model"), vehicle.getAttribute("model"));
		vehicleModel.setVirtual(true);
		vehicleModel.setContextState(contextState);
		NodeLevel test = new NodeLevel(modelManager.getEntityType(org.eclipse.mdm.api.base.model.Test.class));

		env.setChild(project);
		project.setChild(vehicleModel);
		vehicleModel.setChild(test);

		NodeLevel testStep = new NodeLevel(modelManager.getEntityType(TestStep.class));
		NodeLevel measurement = new NodeLevel(modelManager.getEntityType(Measurement.class));
		NodeLevel channelGroup = new NodeLevel(modelManager.getEntityType(ChannelGroup.class));
		NodeLevel channel = new NodeLevel(modelManager.getEntityType(Channel.class));

		test.setChild(testStep);
		testStep.setChild(measurement);
		measurement.setChild(channelGroup);
		channelGroup.setChild(channel);

		return env;
	}

	private NodeLevel createStructureDefault(ApplicationContext context) {
		ModelManager modelManager = context.getModelManager().get();

		NodeLevel env = new NodeLevel(modelManager.getEntityType(Environment.class));
		NodeLevel project = new NodeLevel(modelManager.getEntityType(Project.class));
		NodeLevel pool = new NodeLevel(modelManager.getEntityType(Pool.class));
		NodeLevel test = new NodeLevel(modelManager.getEntityType(org.eclipse.mdm.api.base.model.Test.class));
		NodeLevel testStep = new NodeLevel(modelManager.getEntityType(TestStep.class));
		NodeLevel measurement = new NodeLevel(modelManager.getEntityType(Measurement.class));
		NodeLevel channelGroup = new NodeLevel(modelManager.getEntityType(ChannelGroup.class));
		NodeLevel channel = new NodeLevel(modelManager.getEntityType(Channel.class));

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

		return env;
	}
}