nucleus/businessobjects/src/test/java/org/eclipse/mdm/nodeprovider/boundary/NodeProviderResourceTest.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.mockito.Mockito.when;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import javax.ws.rs.client.Entity;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.GenericType;
import javax.ws.rs.core.MediaType;

import org.eclipse.mdm.api.base.query.Filter;
import org.eclipse.mdm.nodeprovider.entity.Node;
import org.eclipse.mdm.nodeprovider.entity.NodeProvider;
import org.eclipse.mdm.nodeprovider.entity.NodeProviderResponse;
import org.glassfish.hk2.api.Factory;
import org.glassfish.hk2.utilities.binding.AbstractBinder;
import org.glassfish.jersey.jackson.JacksonFeature;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;

public class NodeProviderResourceTest extends JerseyTest {
	private static NodeProviderService nodeProviderRepository = Mockito.mock(NodeProviderService.class);
	private static NodeProvider nodeProvider = Mockito.mock(NodeProvider.class);
	private Node rootNode;
	private Node childNode;

	public static class NodeProviderRepositoryFactory implements Factory<NodeProviderService> {
		@Override
		public void dispose(NodeProviderService nodeProviderRepository) {
			// nothing to do here
		}

		@Override
		public NodeProviderService provide() {
			return nodeProviderRepository;
		}
	}

	@Override
	public Application configure() {
		ResourceConfig config = new ResourceConfig();

		config.register(new AbstractBinder() {
			@Override
			protected void configure() {
				bindFactory(NodeProviderRepositoryFactory.class).to(NodeProviderService.class);
			}
		});

		config.register(NodeProviderResource.class);
		config.register(JacksonFeature.class);
		return config;
	}

	@Before
	public void init() {
		when(nodeProviderRepository.getNodeProviderNames()).thenReturn(Collections.emptyList());
		when(nodeProviderRepository.getNodeProvider("default")).thenReturn(nodeProvider);

		rootNode = new Node("MDM", "Project", "1", "Id", Filter.and(), "Project1");
		childNode = new Node("MDM", "Pool", "2", "Id", Filter.and(), "Pool1");

		when(nodeProvider.getRoots()).thenReturn(Arrays.asList(rootNode));
		when(nodeProvider.getChildren(Mockito.any())).thenReturn(Arrays.asList(childNode));
		when(nodeProvider.getTreePath(Mockito.any())).thenReturn(Arrays.asList(rootNode, childNode));
	}

	@Test
	public void testGetNodeProviders() {
		when(nodeProviderRepository.getNodeProviderNames()).thenReturn(Arrays.asList("default", "generic"));
		List<String> nodeProviderNames = target("nodeprovider").request().get(new GenericType<List<String>>() {
		});
		assertThat(nodeProviderNames).containsExactly("default", "generic");
	}

	@Test
	public void testGetRoots() {
		NodeProviderResponse nodes = target("nodeprovider/default/").request().get(NodeProviderResponse.class);
		assertThat(nodes.getData()).hasSize(1).contains(rootNode);
	}

	@Test
	public void testGetChildren() {
		NodeProviderResponse nodes = target("nodeprovider/default/" + rootNode.getSerial()).request()
				.get(NodeProviderResponse.class);
		assertThat(nodes.getData()).contains(childNode);
	}

	@Test
	public void testGetTreePath() {
		Node node = new Node("MDM", "Project", "1", "Id", Filter.and(), "Project1");

		NodeProviderResponse nodes = target("nodeprovider/default/").request()
				.post(Entity.entity(node, MediaType.APPLICATION_JSON_TYPE), NodeProviderResponse.class);

		assertThat(nodes.getData()).containsExactly(rootNode, childNode);
	}
}