path: root/vid-app-common/src/test/java/org/onap/vid/services/AaiServiceImplTest.java

/*-
 * ============LICENSE_START=======================================================
 * VID
 * ================================================================================
 * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
 * Modifications Copyright (C) 2018 - 2019 Nokia. All rights reserved.
 * ================================================================================
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ============LICENSE_END=========================================================
 */

package org.onap.vid.services;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.joshworks.restclient.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.jetbrains.annotations.NotNull;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.onap.vid.aai.AaiClientInterface;
import org.onap.vid.aai.AaiGetVnfResponse;
import org.onap.vid.aai.AaiOverTLSClientInterface;
import org.onap.vid.aai.AaiResponse;
import org.onap.vid.aai.AaiResponseTranslator;
import org.onap.vid.aai.ServiceInstancesSearchResults;
import org.onap.vid.aai.ServiceSubscription;
import org.onap.vid.aai.ServiceSubscriptions;
import org.onap.vid.aai.Services;
import org.onap.vid.aai.SubscriberFilteredResults;
import org.onap.vid.aai.model.AaiGetInstanceGroupsByCloudRegion;
import org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.AaiGetRelatedInstanceGroupsByVnfId;
import org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.RelatedToProperty;
import org.onap.vid.aai.model.AaiGetOperationalEnvironments.OperationalEnvironmentList;
import org.onap.vid.aai.model.AaiGetPnfs.Pnf;
import org.onap.vid.aai.model.AaiGetServicesRequestModel.GetServicesAAIRespone;
import org.onap.vid.aai.model.AaiGetTenatns.GetTenantsResponse;
import org.onap.vid.aai.model.GetServiceModelsByDistributionStatusResponse;
import org.onap.vid.aai.model.InstanceGroupInfo;
import org.onap.vid.aai.model.LogicalLinkResponse;
import org.onap.vid.aai.model.Model;
import org.onap.vid.aai.model.ModelVer;
import org.onap.vid.aai.model.ModelVers;
import org.onap.vid.aai.model.PortDetailsTranslator;
import org.onap.vid.aai.model.Properties;
import org.onap.vid.aai.model.Relationship;
import org.onap.vid.aai.model.RelationshipData;
import org.onap.vid.aai.model.RelationshipList;
import org.onap.vid.aai.model.Result;
import org.onap.vid.aai.model.ServiceRelationships;
import org.onap.vid.aai.model.VnfResult;
import org.onap.vid.asdc.beans.Service;
import org.onap.vid.model.Subscriber;
import org.onap.vid.model.SubscriberList;
import org.onap.vid.model.aaiTree.AAITreeNode;
import org.onap.vid.model.aaiTree.RelatedVnf;
import org.onap.vid.model.aaiTree.ServiceInstance;
import org.onap.vid.roles.RoleValidator;

import javax.ws.rs.core.Response;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class AaiServiceImplTest {

	private static final String GLOBAL_CUSTOMER_ID = "GLOBAL_CUSTOMER_ID";
	private static final String CLOUD_REGION_ID = "CLOUD_REGION_ID";
	private static final String VNF_TYPE = "VNF_TYPE";
	private static final String TENANT_ID = "TENANT_ID";
	private static final String TENANT_NAME = "TENANT_NAME";
	private static final String SERVICE_TYPE = "SERVICE_TYPE";
	private static final String CORRECT_VALUE = "CORRECT_VALUE";
	private static final String SUBSCRIBER_ID = "SUBSCRIBER_ID_EXPECTED";
	private static final String STATUS_TEXT = "STATUS_TEXT";
	private static final String GLOBAL_SUBSCRIBER_ID = "GLOBAL_SUBSCRIBER_ID";
	private static final String GLOBAL_SUBSCRIBER_ID_NULL_RESPONSE = "ID_NULL";
	private static final String VNF_INSTANCE_ID_OK = "VNF_INSTANCE_ID_OK";
	private static final String VNF_INSTANCE_ID_FAIL = "VNF_INSTANCE_ID_FAIL";
	private static final String PARENT_NAME = "PARENT_NAME";
	private static final String PARENT_ID = "PARENT_ID";
	private static final String INVARIANT_ID = "INVARIANT_ID";
	private static final String GROUP_TYPE_FAILING = "GROUP_TYPE_FAILING";
	private static final String GROUP_ROLE_OK = "GROUP_ROLE_OK";
	private static final String GROUP_ROLE_FAILING = "GROUP_ROLE_FAILING";
	private static final String group_type_ok = "GROUP_TYPE_OK";
	private static final String CLOUD_TYPE = "CLOUD_TYPE";

	@Mock
	private HttpResponse<SubscriberList> responseAllSubscribers;
	@Mock
	private AaiResponse<OperationalEnvironmentList> aaiResponseOpEnvList;
	@Mock
	private AaiResponse aaiResponse;
	@Mock
	private AaiResponse<JsonNode> aaiResponseJsonNode;
	@Mock
	private RoleValidator roleValidator;

	@Mock
	private AaiClientInterface aaiClient;
	@Mock
	private AaiOverTLSClientInterface aaiOverTLSClient;
	@Mock
	private AaiResponseTranslator aaiResponseTranslator;
	@Mock
	private AAIServiceTree aaiServiceTree;

	@InjectMocks
	private AaiServiceImpl aaiService;


	@Test
	public void shouldGetFullSubscriberListWithoutValidator() {
		when(aaiOverTLSClient.getAllSubscribers()).thenReturn(responseAllSubscribers);

		HttpResponse<SubscriberList> actualResponse = aaiService.getFullSubscriberList();

		assertThat(actualResponse).isEqualTo(responseAllSubscribers);
	}

	@Test
	public void shouldGetFullSubscriberListWithValidator() {
		Subscriber subscriber = createSubscriber();
		SubscriberList subscriberList = new SubscriberList(Collections.singletonList(subscriber));

		when(aaiOverTLSClient.getAllSubscribers()).thenReturn(responseAllSubscribers);
		when(responseAllSubscribers.getBody()).thenReturn(subscriberList);
		when(responseAllSubscribers.getStatusText()).thenReturn(STATUS_TEXT);
		when(responseAllSubscribers.getStatus()).thenReturn(HttpStatus.SC_OK);
		SubscriberFilteredResults expectedSubscribers = new SubscriberFilteredResults(roleValidator, subscriberList,
				STATUS_TEXT, HttpStatus.SC_OK);

		SubscriberFilteredResults actualSubscribers = aaiService.getFullSubscriberList(roleValidator);

		assertThat(actualSubscribers.getHttpCode()).isEqualTo(expectedSubscribers.getHttpCode());
		assertThat(actualSubscribers.getErrorMessage()).isEqualTo(expectedSubscribers.getErrorMessage());
	}

	@Test
	public void shouldGetOperationalEnvironments() {
		when(aaiClient.getOperationalEnvironments(anyString(), anyString()))
				.thenReturn(aaiResponseOpEnvList);

		AaiResponse<OperationalEnvironmentList> expectedEnvList =
				aaiService.getOperationalEnvironments(anyString(), anyString());

		assertThat(expectedEnvList).isEqualTo(aaiResponseOpEnvList);
	}

	@Test
	public void shouldGetSubscriberData() {
		Services services = createAaiResponseServices();
		AaiResponse<Services> aaiResponseServices = new AaiResponse<>(services, null, HttpStatus.SC_OK);

		when(aaiClient.getSubscriberData(SUBSCRIBER_ID)).thenReturn(aaiResponseServices);
		when(roleValidator.isServicePermitted(eq(GLOBAL_CUSTOMER_ID), anyString())).thenReturn(Boolean.TRUE);

		AaiResponse actualResponse = aaiService.getSubscriberData(SUBSCRIBER_ID, roleValidator);
		List<ServiceSubscription> actualServiceSubscriptions = ((AaiResponse<Services>) actualResponse)
				.getT().serviceSubscriptions.serviceSubscription;

		assertThat(actualResponse).isEqualTo(aaiResponseServices);
		assertThat(actualServiceSubscriptions).allMatch(s -> s.isPermitted);
	}

	@Test
	public void shouldGetServiceInstanceEmptySearchResults() {
		ServiceInstancesSearchResults serviceInstancesSearchResults = new ServiceInstancesSearchResults();
		AaiResponse<ServiceInstancesSearchResults> emptyResponse = new AaiResponse<>(serviceInstancesSearchResults,
				null, HttpStatus.SC_OK);

		AaiResponse actualResponse = aaiService.getServiceInstanceSearchResults(null, null,
				null, null, null);

		assertThat(actualResponse).isEqualToComparingFieldByFieldRecursively(emptyResponse);
	}

	@Test
	public void shouldGetVersionByInvariantId() {
		Response response = mock(Response.class);
		when(aaiClient.getVersionByInvariantId(any())).thenReturn(response);

		Response actualResponse = aaiService.getVersionByInvariantId(any());

		assertThat(actualResponse).isEqualTo(response);
	}

	@Test
	public void shouldGetSpecificPnf() {
		AaiResponse<Pnf> expectedResponse = new AaiResponse<>(Pnf.builder().build(), null, HttpStatus.SC_OK);
		when(aaiClient.getSpecificPnf(anyString())).thenReturn(expectedResponse);

		AaiResponse<Pnf> actualResponse = aaiService.getSpecificPnf(anyString());

		assertThat(actualResponse).isEqualTo(expectedResponse);
	}

	@Test
	public void shouldGetPnfData() {
		when(aaiClient.getPNFData(anyString(), anyString(), anyString(), anyString(), anyString(), anyString(),
				anyString())).thenReturn(aaiResponse);

		AaiResponse actualResponse = aaiService.getPNFData(anyString(), anyString(), anyString(), anyString(),
				anyString(), anyString(), anyString());

		assertThat(actualResponse).isEqualTo(aaiResponse);
	}

	@Test
	public void shouldGetServices() {
		org.onap.vid.aai.model.AaiGetServicesRequestModel.Service s1 =
				createService("ID1", "V1", "D1");
		org.onap.vid.aai.model.AaiGetServicesRequestModel.Service s2 =
				createService("ID2", "V2", "D2");

		GetServicesAAIRespone services = new GetServicesAAIRespone();
		services.service = Arrays.asList(s1, s2);

		AaiResponse<GetServicesAAIRespone> aaiResponseServices =
				new AaiResponse<>(services, null, HttpStatus.SC_OK);

		when(aaiClient.getServices()).thenReturn(aaiResponseServices);

		Object actualObjectOfResponse = aaiService.getServices(roleValidator).getT();

		assertThat(actualObjectOfResponse).isNotNull();
		assertThat(((GetServicesAAIRespone) actualObjectOfResponse).service).allMatch(s -> s.isPermitted);
	}

	@Test
	public void shouldGetTenants() {
		GetTenantsResponse tenant1 = new GetTenantsResponse("REGION_ID1", "CLOUD_OWNER1",
				"TENANT_NAME1", "TENANT_ID1", true);
		GetTenantsResponse tenant2 = new GetTenantsResponse("REGION_ID2", "CLOUD_OWNER2",
				"TENANT_NAME2", "TENANT_ID2", false);
		GetTenantsResponse[] tenants = {tenant1, tenant2};
		AaiResponse<GetTenantsResponse[]> aaiGetTenantsResponse = new AaiResponse<>(tenants,
				null, HttpStatus.SC_OK);

		when(aaiClient.getTenants(anyString(), anyString())).thenReturn(aaiGetTenantsResponse);
		when(roleValidator.isTenantPermitted(anyString(), anyString(), anyString()))
				.thenReturn(Boolean.TRUE);

		GetTenantsResponse[] actualResponses = aaiService
				.getTenants(anyString(), anyString(), roleValidator).getT();

		assertThat(actualResponses).isNotNull();
		assertThat(actualResponses.length).isEqualTo(2);
		assertThat(actualResponses).allMatch(tenant -> tenant.isPermitted);
	}

	@Test
	public void shouldGetVNFDataWithoutFiltering() {
		when(aaiClient.getVNFData(anyString(), anyString(), anyString())).thenReturn(aaiResponse);

		AaiResponse actualResponse = aaiService.getVNFData(anyString(), anyString(), anyString());

		assertThat(actualResponse).isEqualTo(aaiResponse);
	}

	@Test
	public void shouldGetVNFDataWithFiltering() {
		VnfResult vnfResult1 = createVnfResult("ID1", "generic-vnf");
		VnfResult vnfResult2 = createVnfResult("ID2", "service-instance");
		VnfResult vnfResult3 = createVnfResult("ID3", "anything-else");

		List<VnfResult> vnfResults = Arrays.asList(vnfResult1, vnfResult2, vnfResult3);
		AaiResponse<AaiGetVnfResponse> aaiResponseGetVnfResponse = createAaiResponseVnfResponse(vnfResults);

		vnfResults = Arrays.asList(vnfResult1, vnfResult2);
		AaiResponse<AaiGetVnfResponse> expectedResponseWithReturnedVnfs = createAaiResponseVnfResponse(vnfResults);
		AaiResponse expectedResponseWithoutReturnedVnfs = new AaiResponse();

		when(aaiClient.getVNFData(GLOBAL_SUBSCRIBER_ID, SERVICE_TYPE)).thenReturn(aaiResponseGetVnfResponse);
		when(aaiClient.getVNFData(GLOBAL_SUBSCRIBER_ID_NULL_RESPONSE, SERVICE_TYPE)).thenReturn(null);

		AaiResponse<AaiGetVnfResponse> actualResponseWithReturnedVnfs =
				aaiService.getVNFData(GLOBAL_SUBSCRIBER_ID, SERVICE_TYPE);
		AaiResponse<AaiGetVnfResponse> actualResponseWithoutReturnedVnfs =
				aaiService.getVNFData(GLOBAL_SUBSCRIBER_ID_NULL_RESPONSE, SERVICE_TYPE);

		assertThat(actualResponseWithReturnedVnfs)
				.isEqualToComparingFieldByFieldRecursively(expectedResponseWithReturnedVnfs);
		assertThat(actualResponseWithoutReturnedVnfs)
				.isEqualToComparingFieldByField(expectedResponseWithoutReturnedVnfs);
	}

	@Test
	public void shouldGetAaiZones() {
		when(aaiClient.getAllAicZones()).thenReturn(aaiResponse);

		AaiResponse actualResponse = aaiService.getAaiZones();

		assertThat(actualResponse).isEqualTo(aaiResponse);
	}

	@Test
	public void shouldGetAicZoneForPnf() {
		ServiceRelationships relationsService = createServiceRelationships();
		AaiResponse<ServiceRelationships> expectedServiceInstanceResp =
				new AaiResponse<>(relationsService, null, HttpStatus.SC_OK);
		AaiResponse<String> expectedResponse = new AaiResponse<>(CORRECT_VALUE, null, HttpStatus.SC_OK);

		when(aaiClient.getServiceInstance(anyString(), anyString(), anyString()))
				.thenReturn(expectedServiceInstanceResp);

		AaiResponse actualResponse = aaiService.getAicZoneForPnf(anyString(), anyString(), anyString());

		assertThat(actualResponse).isEqualToComparingFieldByField(expectedResponse);
	}

	@Test
	public void shouldGetNodeTemplateInstances() {
		when(aaiClient.getNodeTemplateInstances(anyString(), anyString(), anyString(),
				anyString(), anyString())).thenReturn(aaiResponse);

		AaiResponse expectedResponse = aaiService.getNodeTemplateInstances(anyString(), anyString(), anyString(),
				anyString(), anyString());

		assertThat(expectedResponse).isEqualTo(aaiResponse);
	}

	@Test
	public void shouldGetNetworkCollectionDetails() {
		when(aaiClient.getNetworkCollectionDetails(anyString())).thenReturn(aaiResponse);

		AaiResponse expectedResponse = aaiService.getNetworkCollectionDetails(anyString());

		assertThat(expectedResponse).isEqualTo(aaiResponse);
	}

	@Test
	public void shouldGetInstanceGroupsByCloudRegion() {
		AaiGetInstanceGroupsByCloudRegion aaiGetInstanceGroupsByCloudRegion =
				mock(AaiGetInstanceGroupsByCloudRegion.class);
		AaiResponse<AaiGetInstanceGroupsByCloudRegion> expectedResponse =
				new AaiResponse<>(aaiGetInstanceGroupsByCloudRegion, null, HttpStatus.SC_OK);

		when(aaiClient.getInstanceGroupsByCloudRegion(anyString(), anyString(), anyString()))
				.thenReturn(expectedResponse);
		AaiResponse<AaiGetInstanceGroupsByCloudRegion> actualResponse =
				aaiService.getInstanceGroupsByCloudRegion(anyString(), anyString(), anyString());

		assertThat(actualResponse).isEqualTo(expectedResponse);
	}

	@Test
	public void shouldGetServicesByDistributionStatus() {
		Result resultWithModelType = createResult("MODEL_TYPE1", "1");
		Result resultWithEmptyModelType = createResult(null, "2");
		Result resultWithoutModel = new Result();
		resultWithoutModel.setModel(null);
		Result resultWithoutValidModel = createResultWithoutValidModel();
		List<Result> results = Arrays.asList(resultWithModelType, resultWithEmptyModelType, resultWithoutModel,
				resultWithoutValidModel);

		GetServiceModelsByDistributionStatusResponse serviceModels = new GetServiceModelsByDistributionStatusResponse();
		serviceModels.setResults(results);

		AaiResponse<GetServiceModelsByDistributionStatusResponse> serviceModelsByDistributionStatusResponse
				= new AaiResponse<>(serviceModels, null, HttpStatus.SC_OK);

		Service[] expectedServices = {
				createService("MODEL_TYPE1", "1"),
				createService("", "2")
		};

		when(aaiClient.getServiceModelsByDistributionStatus()).thenReturn(serviceModelsByDistributionStatusResponse);
		Collection<Service> actualServices = aaiService.getServicesByDistributionStatus();

		assertThat(actualServices)
				.hasSize(2)
				.usingFieldByFieldElementComparator()
				.containsExactly(expectedServices);
	}

	@Test
	public void shouldReturnEmptyListOfServices() {
		AaiResponse<GetServiceModelsByDistributionStatusResponse> emptyResponse
				= new AaiResponse<>(null, null, HttpStatus.SC_OK);

		when(aaiClient.getServiceModelsByDistributionStatus()).thenReturn(emptyResponse);
		Collection<Service> actualServices = aaiService.getServicesByDistributionStatus();

		assertThat(actualServices).isEqualTo(Collections.EMPTY_LIST);
	}

	@Test
	public void shouldGetServiceInstanceAssociatedPnfs() {
		ServiceRelationships relationsList = createServiceRelationships();
		LogicalLinkResponse logicalLinkResponse = new LogicalLinkResponse();
		logicalLinkResponse.setRelationshipList(relationsList.getRelationshipList());

		AaiResponse<LogicalLinkResponse> aaiResponseLogicalLinkResponse =
				new AaiResponse<>(logicalLinkResponse, null, HttpStatus.SC_OK);
		AaiResponse<ServiceRelationships> aaiResponseServiceRelations =
				new AaiResponse<>(relationsList, null, HttpStatus.SC_OK);

		when(aaiClient.getServiceInstance(anyString(), anyString(), anyString()))
				.thenReturn(aaiResponseServiceRelations);
		when(aaiClient.getLogicalLink(anyString())).thenReturn(aaiResponseLogicalLinkResponse);


		List<String> expectedPnfs = Collections.singletonList(CORRECT_VALUE);
		List<String> actualPnfs = aaiService.getServiceInstanceAssociatedPnfs(anyString(), anyString(), anyString());

		assertThat(actualPnfs).isEqualTo(expectedPnfs);
	}

	@Test
	public void shouldGetPortMirroringConfigData() {
		AaiResponseTranslator.PortMirroringConfigData expectedData
				= mock(AaiResponseTranslator.PortMirroringConfigData.class);

		when(aaiClient.getCloudRegionAndSourceByPortMirroringConfigurationId(anyString())).thenReturn(aaiResponseJsonNode);
		when(aaiResponseTranslator.extractPortMirroringConfigData(aaiResponseJsonNode)).thenReturn(expectedData);

		AaiResponseTranslator.PortMirroringConfigData actualData = aaiService.getPortMirroringConfigData(anyString());
		assertThat(actualData).isEqualTo(expectedData);
	}


	@Test
	public void shouldGetInstanceGroupsByVnfInstanceId() {
		List<InstanceGroupInfo> instanceGroupInfo = Collections.singletonList(new InstanceGroupInfo(CORRECT_VALUE));
		AaiGetRelatedInstanceGroupsByVnfId relatedInstanceGroups = new AaiGetRelatedInstanceGroupsByVnfId();
		relatedInstanceGroups.setRelationshipList(createRelationshipList());

		AaiResponse<AaiGetRelatedInstanceGroupsByVnfId> correctCodeResponse =
				new AaiResponse<>(relatedInstanceGroups, null, HttpStatus.SC_OK);

		AaiResponse<List<InstanceGroupInfo>> expectedCorrectCodeResponse =
				new AaiResponse<>(instanceGroupInfo, null, HttpStatus.SC_OK);
		AaiResponse<AaiGetRelatedInstanceGroupsByVnfId> expectedIncorrectCodeResponse =
				new AaiResponse<>(relatedInstanceGroups, null, HttpStatus.SC_PAYMENT_REQUIRED);
		List<InstanceGroupInfo> expectedCorrectResponseObject = expectedCorrectCodeResponse.getT();

		when(aaiClient.getInstanceGroupsByVnfInstanceId(VNF_INSTANCE_ID_OK)).thenReturn(correctCodeResponse);
		when(aaiClient.getInstanceGroupsByVnfInstanceId(VNF_INSTANCE_ID_FAIL)).thenReturn(expectedIncorrectCodeResponse);

		AaiResponse actualCorrectCodeResponse = aaiService.getInstanceGroupsByVnfInstanceId(VNF_INSTANCE_ID_OK);
		AaiResponse actualIncorrectCodeResponse = aaiService.getInstanceGroupsByVnfInstanceId(VNF_INSTANCE_ID_FAIL);

		List<InstanceGroupInfo> actualCorrectResponseObject =
				(List<InstanceGroupInfo>) actualCorrectCodeResponse.getT();

		assertThat(actualCorrectResponseObject)
				.usingFieldByFieldElementComparator()
				.hasSameElementsAs(expectedCorrectResponseObject);

		assertThat(actualIncorrectCodeResponse).isEqualTo(expectedIncorrectCodeResponse);
	}

	@Test
	public void shouldGetHomingDataByVfModule() {
		GetTenantsResponse expectedResponse = new GetTenantsResponse();
		when(aaiClient.getHomingDataByVfModule(anyString(), anyString())).thenReturn(expectedResponse);

		GetTenantsResponse actualResponse = aaiService.getHomingDataByVfModule(anyString(), anyString());
		assertThat(actualResponse).isEqualTo(expectedResponse);
	}

	@Test
	public void shouldSearchGroupMembers() {
		Properties properties = createProperties();
		Map<String, Properties> regionsAndTenants = createRegionsAndTenantsMap(properties);

		AAITreeNode validTreeNode = new AAITreeNode();
		addAdditionalPropertiesToAaiTreeNode(validTreeNode);
		List<AAITreeNode> validNodes = Arrays.asList(validTreeNode, validTreeNode);

		AAITreeNode validBranch = createTree(validNodes);
		addAdditionalPropertiesToAaiTreeNode(validBranch);
		List<AAITreeNode> testedBranches = Collections.singletonList(validBranch);

		AAITreeNode testedTree = createTree(testedBranches);

		RelatedVnf expectedVnf = createExpectedVnf(validBranch);
		List<RelatedVnf> expectedResult = Collections.singletonList(expectedVnf);

		when(aaiServiceTree.buildAAITree(anyString(), any())).thenReturn(Collections.singletonList(testedTree));
		when(aaiClient.getCloudRegionAndTenantByVnfId(anyString())).thenReturn(regionsAndTenants);

		List<RelatedVnf> actualGroupMembers = aaiService.searchGroupMembers(GLOBAL_CUSTOMER_ID, SERVICE_TYPE,
				INVARIANT_ID, GROUP_TYPE_FAILING, GROUP_ROLE_FAILING);

		assertThat(actualGroupMembers)
				.usingFieldByFieldElementComparator()
				.hasSameElementsAs(expectedResult);
	}

	@Test
	public void shouldGetPortMirroringSourcePorts() {
		PortDetailsTranslator.PortDetails details = mock(PortDetailsTranslator.PortDetails.class);
		List<PortDetailsTranslator.PortDetails> expectedDetailsList = Arrays.asList(
				details, details, details
		);

		when(aaiClient.getPortMirroringSourcePorts(anyString())).thenReturn(expectedDetailsList);
		List<PortDetailsTranslator.PortDetails> actualDetails = aaiService.getPortMirroringSourcePorts(anyString());

		assertThat(actualDetails).isEqualTo(expectedDetailsList);
	}

	@Test
	public void shouldGetAAIServiceTree() throws JsonProcessingException {
		ServiceInstance serviceInstance = mock(ServiceInstance.class);
		String expectedResult = new ObjectMapper().writeValueAsString(serviceInstance);

		when(aaiServiceTree.getServiceInstanceTopology(anyString(), anyString(), anyString()))
				.thenReturn(serviceInstance);
		String actualResult = aaiService.getAAIServiceTree(anyString(), anyString(), anyString());

		assertThat(actualResult).isEqualTo(expectedResult);
	}

	@NotNull
	private Map<String, Properties> createRegionsAndTenantsMap(Properties properties) {
		Map<String, Properties> regionsAndTenants = new HashMap<>();
		regionsAndTenants.put("tenant", properties);
		regionsAndTenants.put("cloud-region", properties);
		return regionsAndTenants;
	}

	private Properties createProperties() {
		Properties properties = new Properties();
		properties.setTenantId(TENANT_ID);
		properties.setTenantName(TENANT_NAME);
		properties.setCloudRegionId(CLOUD_REGION_ID);
		return properties;
	}

	@NotNull
	private RelatedVnf createExpectedVnf(AAITreeNode validBranch) {
		RelatedVnf expectedVnf = RelatedVnf.from(validBranch);
		expectedVnf.setTenantId(TENANT_ID);
		expectedVnf.setTenantName(TENANT_NAME);
		expectedVnf.setLcpCloudRegionId(CLOUD_REGION_ID);
		expectedVnf.setServiceInstanceId(PARENT_ID);
		expectedVnf.setServiceInstanceName(PARENT_NAME);
		expectedVnf.setInstanceType(VNF_TYPE);

		return expectedVnf;
	}


	private AAITreeNode createTree(List<AAITreeNode> children) {
		AAITreeNode tree = new AAITreeNode();
		tree.addChildren(children);
		tree.setId(PARENT_ID);
		tree.setName(PARENT_NAME);
		return tree;
	}

	private void addAdditionalPropertiesToAaiTreeNode(AAITreeNode tree) {
		Map<String, Object> additionalProperties = new HashMap<>();
		additionalProperties.put("instance-group-role", GROUP_ROLE_OK);
		additionalProperties.put("instance-group-type", group_type_ok);
		additionalProperties.put("vnf-type", VNF_TYPE);
		additionalProperties.put("cloud-region", CLOUD_TYPE);
		tree.setAdditionalProperties(additionalProperties);
	}

	private org.onap.vid.asdc.beans.Service createService(String category, String suffix) {
		return new Service.ServiceBuilder()
				.setUuid("MODELVER_VERSION_ID" + suffix)
				.setInvariantUUID("MODEL_INVARIANT_NAME" + suffix)
				.setCategory(category)
				.setVersion("MODELVER_VERSION" + suffix)
				.setName("MODELVER_NAME" + suffix)
				.setDistributionStatus("MODELVER_DIST_STATUS" + suffix)
				.setToscaModelURL(null)
				.setLifecycleState(null)
				.setArtifacts(null)
				.setResources(null)
				.build();
	}

	@NotNull
	private Result createResultWithoutValidModel() {
		ModelVers modelVers = new ModelVers();
		modelVers.setModelVer(Collections.singletonList(new ModelVer()));

		Model model = new Model();
		model.setModelVers(modelVers);

		Result result1 = new Result();
		result1.setModel(model);
		return result1;
	}

	@NotNull
	private Result createResult(String modelType, String suffix) {
		ModelVer modelVer = new ModelVer();
		modelVer.setModelVersionId("MODELVER_VERSION_ID" + suffix);
		modelVer.setModelVersion("MODELVER_VERSION" + suffix);
		modelVer.setModelName("MODELVER_NAME" + suffix);
		modelVer.setDistributionStatus("MODELVER_DIST_STATUS" + suffix);

		ModelVers modelVers = new ModelVers();
		modelVers.setModelVer(Collections.singletonList(modelVer));

		Model model = new Model();
		model.setModelType(modelType);
		model.setModelInvariantId("MODEL_INVARIANT_NAME" + suffix);
		model.setModelVers(modelVers);

		Result result = new Result();
		result.setModel(model);
		return result;
	}

	@NotNull
	private ServiceRelationships createServiceRelationships() {
		RelationshipList relationsList = createRelationshipList(CORRECT_VALUE);
		ServiceRelationships relationsService = new ServiceRelationships();
		relationsService.setRelationshipList(relationsList);
		return relationsService;
	}

	@NotNull
	private RelationshipList createRelationshipList(String expectedValue) {
		List<RelationshipData> relationsDataList = createRelationshipDataList(expectedValue);
		return createRelationshipList(relationsDataList);
	}

	@NotNull
	private RelationshipList createRelationshipList(List<RelationshipData> relationsDataList) {
		Relationship relation1 = crateRelationship("any", relationsDataList);
		Relationship relation2 = crateRelationship("zone", relationsDataList);
		Relationship relation3 = crateRelationship("logical-link", relationsDataList);
		Relationship relation4 = crateRelationship("lag-interface", relationsDataList);
		Relationship relation5 = crateRelationship("pnf", relationsDataList);

		RelationshipList relationsList = new RelationshipList();
		relationsList.setRelationship(Arrays.asList(relation1, relation2, relation3, relation4, relation5));
		return relationsList;
	}

	@NotNull
	private List<RelationshipData> createRelationshipDataList(String expectedValue) {
		RelationshipData relationData1 = createRelationshipData("any-key", "incorrect_key");
		RelationshipData relationData2 = createRelationshipData("zone.zone-id", expectedValue);
		RelationshipData relationData3 = createRelationshipData("logical-link.link-name", expectedValue);
		RelationshipData relationData4 = createRelationshipData("pnf.pnf-name", expectedValue);

		return Arrays.asList(relationData1, relationData2, relationData3, relationData4);
	}

	@NotNull
	private Relationship crateRelationship(String relatedTo, List<RelationshipData> relationsDataList) {
		Relationship relation = new Relationship();
		relation.setRelatedTo(relatedTo);
		relation.setRelationDataList(relationsDataList);
		return relation;
	}

	@NotNull
	private RelationshipData createRelationshipData(String key, String value) {
		RelationshipData relationData = new RelationshipData();
		relationData.setRelationshipKey(key);
		relationData.setRelationshipValue(value);
		return relationData;
	}

	private org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.RelationshipList createRelationshipList() {
		RelatedToProperty property1 =
				createRelatedToProperty("instance-group.instance-group-name", CORRECT_VALUE);
		RelatedToProperty property2 =
				createRelatedToProperty("anything-key", "anything-value");
		List<RelatedToProperty> properties = Arrays.asList(property1, property2);

		org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Relationship relationship1 =
				createRelationship("instance-group", properties);
		org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Relationship relationship2 =
				createRelationship("any-key", properties);

		List<org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Relationship> relationships =
				Arrays.asList(relationship1, relationship2);

		org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.RelationshipList relationshipList =
				new org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.RelationshipList();
		relationshipList.setRelationship(relationships);

		return relationshipList;
	}

	@NotNull
	private org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Relationship createRelationship(String relatedTo,
	                                                                                              List<RelatedToProperty> relatedToPropertyList) {
		org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Relationship relationship1 =
				new org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Relationship();
		relationship1.setRelatedTo(relatedTo);
		relationship1.setRelatedToPropertyList(relatedToPropertyList);
		return relationship1;
	}

	@NotNull
	private RelatedToProperty createRelatedToProperty(String key, String value) {
		RelatedToProperty prop = new RelatedToProperty();
		prop.setPropertyKey(key);
		prop.setPropertyValue(value);
		return prop;
	}

	@NotNull
	private AaiResponse<AaiGetVnfResponse> createAaiResponseVnfResponse(List<VnfResult> vnfResults) {
		AaiGetVnfResponse vnfResponse = new AaiGetVnfResponse();
		vnfResponse.setResults(vnfResults);
		return new AaiResponse<>(vnfResponse, null, HttpStatus.SC_OK);
	}

	private VnfResult createVnfResult(String id, String nodeType) {
		VnfResult result = new VnfResult();
		result.setJsonId(id);
		result.setJsonNodeType(nodeType);
		return result;
	}


	private org.onap.vid.aai.model.AaiGetServicesRequestModel.Service createService(String serviceId,
	                                                                                String resourceVersion,
	                                                                                String serviceDescription) {
		org.onap.vid.aai.model.AaiGetServicesRequestModel.Service service
				= new org.onap.vid.aai.model.AaiGetServicesRequestModel.Service();
		service.isPermitted = false;
		service.resourceVersion = resourceVersion;
		service.serviceDescription = serviceDescription;
		service.serviceId = serviceId;
		return service;
	}

	@NotNull
	private Services createAaiResponseServices() {
		ServiceSubscription sub1 = new ServiceSubscription();
		sub1.isPermitted = false;
		sub1.serviceType = "serviceSubsType1";

		ServiceSubscription sub2 = new ServiceSubscription();
		sub2.isPermitted = true;
		sub2.serviceType = "serviceSubsType2";

		ServiceSubscriptions serviceSubs = new ServiceSubscriptions();
		serviceSubs.serviceSubscription = Collections.singletonList(sub2);

		Services services = new Services();
		services.globalCustomerId = GLOBAL_CUSTOMER_ID;
		services.resourceVersion = "v-1";
		services.subscriberName = "name-1";
		services.subscriberType = "type-1";
		services.serviceSubscriptions = serviceSubs;
		return services;
	}

	@NotNull
	private Subscriber createSubscriber() {
		Subscriber subscriber = new Subscriber();
		subscriber.globalCustomerId = "id-1";
		subscriber.resourceVersion = "v-1";
		subscriber.subscriberName = "name-1";
		subscriber.subscriberType = "type-1";
		return subscriber;
	}
}