Rewrite tests for AaiServiceImpl

Issue-ID: VID-386
Change-Id: I3cbcdada18f2813bc8a4cf442f54df297f5ec945
Signed-off-by: michal.banka <michal.banka@nokia.com>

1 files changed, 754 insertions, 242 deletions

diff --git a/vid-app-common/src/test/java/org/onap/vid/services/AaiServiceImplTest.java b/vid-app-common/src/test/java/org/onap/vid/services/AaiServiceImplTest.java
index e9f94ca0e..068cc0053 100644
--- a/vid-app-common/src/test/java/org/onap/vid/services/AaiServiceImplTest.java
+++ b/vid-app-common/src/test/java/org/onap/vid/services/AaiServiceImplTest.java
@@ -21,258 +21,770 @@
 
 package org.onap.vid.services;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import javax.ws.rs.core.Response;
-import org.jeasy.random.EasyRandom;
-import org.jeasy.random.EasyRandomParameters;
-import org.jeasy.random.randomizers.misc.BooleanRandomizer;
-import org.jeasy.random.randomizers.text.StringRandomizer;
+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 org.onap.vid.roles.RoleValidatorByRoles;
 
+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 long STATIC_SEED = 5336L;
-    private EasyRandomParameters parameters = new EasyRandomParameters()
-        .randomize(String.class, new StringRandomizer(4, 4, STATIC_SEED))
-        .randomize(Boolean.class, new BooleanRandomizer(STATIC_SEED));
-    private EasyRandom modelGenerator = new EasyRandom(parameters);
-
-    private AaiClientInterface aaiClient = mock(AaiClientInterface.class);
-    private AaiOverTLSClientInterface aaiSslClient = mock(AaiOverTLSClientInterface.class);
-    private AaiResponseTranslator aaiResponseTranslator = mock(AaiResponseTranslator.class);
-    private AAITreeNodeBuilder aaiTreeNode = mock(AAITreeNodeBuilder.class);
-    private AAIServiceTree aaiServiceTree = mock(AAIServiceTree.class);
-
-    private AaiServiceImpl aaiService = new AaiServiceImpl(
-        aaiClient, aaiSslClient, aaiResponseTranslator, aaiTreeNode, aaiServiceTree
-    );
-
-    @Test
-    public void shouldRetrievePnf() {
-        // given
-        String globalCustomerId = "global_customer";
-        String serviceType = "service_type";
-        String modelVersionId = "model_version";
-        String modelInvariantId = "model_invariant_id";
-        String cloudRegion = "cloud_region";
-        String equipVendor = "equip_vendor";
-        String equipModel = "equip_model";
-
-        AaiResponse response = mock(AaiResponse.class);
-        when(aaiClient.getPNFData(
-            globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion, equipVendor, equipModel
-        )).thenReturn(response);
-
-        // when
-        AaiResponse actual = aaiService.getPNFData(
-            globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion, equipVendor, equipModel
-        );
-
-        // then
-        assertThat(response).isEqualTo(actual);
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void shouldRetrieveSpecificPnf() {
-        // given
-        String pnfId = "some_pnf_id";
-
-        AaiResponse response = mock(AaiResponse.class);
-        when(aaiClient.getSpecificPnf(pnfId)).thenReturn(response);
-
-        // when
-        AaiResponse actual = aaiService.getSpecificPnf(pnfId);
-
-        // then
-        assertThat(response).isEqualTo(actual);
-    }
-
-    @Test
-    public void shouldRetrieveTenantsByInvariantId() {
-        // given
-        List<String> modelInvariantId = new ArrayList<>();
-
-        Response response = mock(Response.class);
-        when(aaiClient.getVersionByInvariantId(modelInvariantId)).thenReturn(response);
-
-        // when
-        Response actual = aaiService.getVersionByInvariantId(modelInvariantId);
-
-        // then
-        assertThat(response).isEqualTo(actual);
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void shouldRetrieveTenants() {
-        // given
-        String globalCustomerId = "global_customer";
-        String serviceType = "service_type";
-
-        GetTenantsResponse permittedTenant = new GetTenantsResponse(
-            "cloud_region", "cloud_owner", "permitted_tenant", "tenant_id", false
-        );
-        GetTenantsResponse unpermittedTenant = new GetTenantsResponse(
-            "cloud_region", "cloud_owner", "unpermitted_tenant", "tenant_id", false
-        );
-
-        AaiResponse<GetTenantsResponse[]> response = mock(AaiResponse.class);
-        when(response.getT()).thenReturn(new GetTenantsResponse[]{ permittedTenant, unpermittedTenant });
-        when(aaiClient.getTenants(globalCustomerId, serviceType)).thenReturn(response);
-
-        RoleValidator roleValidator = mock(RoleValidatorByRoles.class);
-        when(roleValidator.isTenantPermitted(globalCustomerId, serviceType, "permitted_tenant")).thenReturn(true);
-        when(roleValidator.isTenantPermitted(globalCustomerId, serviceType, "unpermitted_tenant")).thenReturn(false);
-
-        // when
-        AaiResponse actual = aaiService.getTenants(globalCustomerId, serviceType, roleValidator);
-
-        // then
-        assertThat(response).isEqualTo(actual);
-        assertThat(permittedTenant.isPermitted).isTrue();
-        assertThat(unpermittedTenant.isPermitted).isFalse();
-    }
-
-    @Test
-    public void shouldRetrieveVNFs() {
-        // given
-        String globalSubscriber = "global_subscriber";
-        String serviceType = "service_type";
-        String serviceInstanceId = "service_instance";
-
-        AaiResponse response = mock(AaiResponse.class);
-        when(aaiClient.getVNFData(globalSubscriber, serviceType, serviceInstanceId)).thenReturn(response);
-
-        // when
-        AaiResponse actual = aaiService.getVNFData(globalSubscriber, serviceType, serviceInstanceId);
-
-        // then
-        assertThat(response).isEqualTo(actual);
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void shouldRetrieveAndFilterVNFsBySubscriberAndServiceType() {
-        // given
-        String globalSubscriber = "global_subscriber";
-        String serviceType = "service_type";
-
-        VnfResult genericVnf = new VnfResult();
-        genericVnf.nodeType = "generic-vnf";
-
-        VnfResult serviceInstance = new VnfResult();
-        serviceInstance.nodeType = "service-instance";
-
-        VnfResult someVnf = new VnfResult();
-        someVnf.nodeType = "some-vnf";
-
-        AaiResponse<AaiGetVnfResponse> response = mock(AaiResponse.class);
-        AaiGetVnfResponse vnfs = new AaiGetVnfResponse();
-        vnfs.results = Arrays.asList(genericVnf, serviceInstance, someVnf);
-        when(response.getT()).thenReturn(vnfs);
-
-        when(aaiClient.getVNFData(globalSubscriber, serviceType)).thenReturn(response);
-
-        // when
-        AaiResponse actual = aaiService.getVNFData(globalSubscriber, serviceType);
-
-        // then
-        assertThat(response).isEqualTo(actual);
-        assertThat(response.getT().results).containsOnly(genericVnf, serviceInstance);
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void getServicesShouldMarkAllServicesAsPermitted() {
-        // given
-        RoleValidator roleValidator = modelGenerator.nextObject(RoleValidatorByRoles.class);
-
-        GetServicesAAIRespone inputPayload = modelGenerator.nextObject(GetServicesAAIRespone.class);
-        assertThat(inputPayload.service.stream().allMatch(service -> service.isPermitted)).isFalse();
-
-        when(aaiClient.getServices()).thenReturn(new AaiResponse<>(inputPayload, "", 200));
-
-        // when
-        AaiResponse<GetServicesAAIRespone> result = aaiService.getServices(roleValidator);
-        GetServicesAAIRespone outputPayload = result.getT();
-
-        // then
-        assertThat(outputPayload.service.stream().allMatch(service -> service.isPermitted)).isTrue();
-    }
-
-    @Test
-    public void shouldGetNodeTemplateInstances() {
-        // given
-        String globalCustomerId = "gcid";
-        String serviceType = "st";
-        String modelVersionId = "mvid";
-        String modelInvariantId = "miid";
-        String cloudRegion = "cr";
-
-        // when
-        aaiService
-            .getNodeTemplateInstances(globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion);
-
-        // then
-        verify(aaiClient)
-            .getNodeTemplateInstances(globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion);
-    }
-
-    @Test
-    public void shouldGetNetworkCollectionDetails() {
-        // given
-        String serviceInstanceId = "siid";
-
-        // when
-        aaiService.getNetworkCollectionDetails(serviceInstanceId);
-
-        // then
-        verify(aaiClient).getNetworkCollectionDetails(serviceInstanceId);
-    }
-
-    @Test
-    public void shouldGetInstanceGroupsByCloudRegion() {
-        // given
-        String cloudOwner = "co";
-        String cloudRegionId = "crid";
-        String networkFunction = "nf";
-
-        // when
-        aaiService.getInstanceGroupsByCloudRegion(cloudOwner, cloudRegionId, networkFunction);
-
-        // then
-        verify(aaiClient).getInstanceGroupsByCloudRegion(cloudOwner, cloudRegionId, networkFunction);
-    }
-
-    @Test
-    public void getAAIServiceTree() {
-        // given
-        String globalCustomerId = "gcid";
-        String serviceType = "st";
-        String serviceInstanceId = "siid";
-
-        // when
-        aaiService.getAAIServiceTree(globalCustomerId, serviceType, serviceInstanceId);
-
-        // then
-        verify(aaiServiceTree).getServiceInstanceTopology(globalCustomerId, serviceType, serviceInstanceId);
-    }
-}
\ No newline at end of file
+	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<>(new Pnf(), 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;
+	}
+}