Implant vid-app-common org.onap.vid.job (main and test)
[vid.git] / vid-app-common / src / test / java / org / onap / vid / services / AaiServiceImplTest.java
index bb47180..09a5368 100644 (file)
 
 package org.onap.vid.services;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.onap.vid.model.aaiTree.NodeType.SERVICE_INSTANCE;
+
 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 java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import javax.ws.rs.core.Response;
 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.Spy;
 import org.mockito.junit.MockitoJUnitRunner;
 import org.onap.vid.aai.AaiClientInterface;
 import org.onap.vid.aai.AaiGetVnfResponse;
@@ -70,721 +90,711 @@ 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;
+import org.springframework.http.HttpMethod;
 
 @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());
+    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;
+    @Spy
+    private ExecutorService executorService = Executors.newFixedThreadPool(1);
+
+    @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, false)).thenReturn(aaiResponseServices);
+        when(roleValidator.isServicePermitted(eq(GLOBAL_CUSTOMER_ID), anyString())).thenReturn(Boolean.TRUE);
+
+        AaiResponse actualResponse = aaiService.getSubscriberData(SUBSCRIBER_ID, roleValidator, false);
+        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(aaiResponse);
-       }
+        assertThat(actualResponse).isEqualTo(expectedResponse);
+    }
 
-       @Test
-       public void shouldGetVNFDataWithFiltering() {
-               VnfResult vnfResult1 = createVnfResult("ID1", "generic-vnf");
-               VnfResult vnfResult2 = createVnfResult("ID2", "service-instance");
-               VnfResult vnfResult3 = createVnfResult("ID3", "anything-else");
+    @Test
+    public void shouldGetPnfData() {
+        when(aaiClient.getPNFData(anyString(), anyString(), anyString(), anyString(), anyString(), anyString(),
+            anyString())).thenReturn(aaiResponse);
 
-               List<VnfResult> vnfResults = Arrays.asList(vnfResult1, vnfResult2, vnfResult3);
-               AaiResponse<AaiGetVnfResponse> aaiResponseGetVnfResponse = createAaiResponseVnfResponse(vnfResults);
+        AaiResponse actualResponse = aaiService.getPNFData(anyString(), anyString(), anyString(), anyString(),
+            anyString(), anyString(), anyString());
 
-               vnfResults = Arrays.asList(vnfResult1, vnfResult2);
-               AaiResponse<AaiGetVnfResponse> expectedResponseWithReturnedVnfs = createAaiResponseVnfResponse(vnfResults);
-               AaiResponse expectedResponseWithoutReturnedVnfs = new AaiResponse();
+        assertThat(actualResponse).isEqualTo(aaiResponse);
+    }
 
-               when(aaiClient.getVNFData(GLOBAL_SUBSCRIBER_ID, SERVICE_TYPE)).thenReturn(aaiResponseGetVnfResponse);
-               when(aaiClient.getVNFData(GLOBAL_SUBSCRIBER_ID_NULL_RESPONSE, SERVICE_TYPE)).thenReturn(null);
+    @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");
 
-               AaiResponse<AaiGetVnfResponse> actualResponseWithReturnedVnfs =
-                               aaiService.getVNFData(GLOBAL_SUBSCRIBER_ID, SERVICE_TYPE);
-               AaiResponse<AaiGetVnfResponse> actualResponseWithoutReturnedVnfs =
-                               aaiService.getVNFData(GLOBAL_SUBSCRIBER_ID_NULL_RESPONSE, SERVICE_TYPE);
+        GetServicesAAIRespone services = new GetServicesAAIRespone();
+        services.service = Arrays.asList(s1, s2);
 
-               assertThat(actualResponseWithReturnedVnfs)
-                               .isEqualToComparingFieldByFieldRecursively(expectedResponseWithReturnedVnfs);
-               assertThat(actualResponseWithoutReturnedVnfs)
-                               .isEqualToComparingFieldByField(expectedResponseWithoutReturnedVnfs);
-       }
+        AaiResponse<GetServicesAAIRespone> aaiResponseServices =
+            new AaiResponse<>(services, null, HttpStatus.SC_OK);
 
-       @Test
-       public void shouldGetAaiZones() {
-               when(aaiClient.getAllAicZones()).thenReturn(aaiResponse);
+        when(aaiClient.getServices()).thenReturn(aaiResponseServices);
 
-               AaiResponse actualResponse = aaiService.getAaiZones();
+        Object actualObjectOfResponse = aaiService.getServices(roleValidator).getT();
 
-               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);
+        assertThat(actualObjectOfResponse).isNotNull();
+        assertThat(((GetServicesAAIRespone) actualObjectOfResponse).service).allMatch(s -> s.isPermitted);
+    }
 
-               when(aaiClient.getServiceInstance(anyString(), anyString(), anyString()))
-                               .thenReturn(expectedServiceInstanceResp);
+    @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);
 
-               AaiResponse actualResponse = aaiService.getAicZoneForPnf(anyString(), anyString(), anyString());
+        when(aaiClient.getTenants(anyString(), anyString())).thenReturn(aaiGetTenantsResponse);
+        when(roleValidator.isTenantPermitted(anyString(), anyString(), anyString()))
+            .thenReturn(Boolean.TRUE);
 
-               assertThat(actualResponse).isEqualToComparingFieldByField(expectedResponse);
-       }
+        GetTenantsResponse[] actualResponses = aaiService
+            .getTenants(anyString(), anyString(), roleValidator).getT();
 
-       @Test
-       public void shouldGetNodeTemplateInstances() {
-               when(aaiClient.getNodeTemplateInstances(anyString(), anyString(), anyString(),
-                               anyString(), anyString())).thenReturn(aaiResponse);
+        assertThat(actualResponses).isNotNull();
+        assertThat(actualResponses.length).isEqualTo(2);
+        assertThat(actualResponses).allMatch(tenant -> tenant.isPermitted);
+    }
 
-               AaiResponse expectedResponse = aaiService.getNodeTemplateInstances(anyString(), anyString(), anyString(),
-                               anyString(), anyString());
+    @Test
+    public void shouldGetVNFDataWithoutFiltering() {
+        when(aaiClient.getVNFData(anyString(), anyString(), anyString())).thenReturn(aaiResponse);
 
-               assertThat(expectedResponse).isEqualTo(aaiResponse);
-       }
+        AaiResponse actualResponse = aaiService.getVNFData(anyString(), anyString(), anyString());
 
-       @Test
-       public void shouldGetNetworkCollectionDetails() {
-               when(aaiClient.getNetworkCollectionDetails(anyString())).thenReturn(aaiResponse);
-
-               AaiResponse expectedResponse = aaiService.getNetworkCollectionDetails(anyString());
+        assertThat(actualResponse).isEqualTo(aaiResponse);
+    }
 
-               assertThat(expectedResponse).isEqualTo(aaiResponse);
-       }
+    @Test
+    public void shouldGetVNFDataWithFiltering() {
+        VnfResult vnfResult1 = createVnfResult("ID1", "generic-vnf");
+        VnfResult vnfResult2 = createVnfResult("ID2", "service-instance");
+        VnfResult vnfResult3 = createVnfResult("ID3", "anything-else");
 
-       @Test
-       public void shouldGetInstanceGroupsByCloudRegion() {
-               AaiGetInstanceGroupsByCloudRegion aaiGetInstanceGroupsByCloudRegion =
-                               mock(AaiGetInstanceGroupsByCloudRegion.class);
-               AaiResponse<AaiGetInstanceGroupsByCloudRegion> expectedResponse =
-                               new AaiResponse<>(aaiGetInstanceGroupsByCloudRegion, null, HttpStatus.SC_OK);
+        List<VnfResult> vnfResults = Arrays.asList(vnfResult1, vnfResult2, vnfResult3);
+        AaiResponse<AaiGetVnfResponse> aaiResponseGetVnfResponse = createAaiResponseVnfResponse(vnfResults);
 
-               when(aaiClient.getInstanceGroupsByCloudRegion(anyString(), anyString(), anyString()))
-                               .thenReturn(expectedResponse);
-               AaiResponse<AaiGetInstanceGroupsByCloudRegion> actualResponse =
-                               aaiService.getInstanceGroupsByCloudRegion(anyString(), anyString(), anyString());
+        vnfResults = Arrays.asList(vnfResult1, vnfResult2);
+        AaiResponse<AaiGetVnfResponse> expectedResponseWithReturnedVnfs = createAaiResponseVnfResponse(vnfResults);
+        AaiResponse expectedResponseWithoutReturnedVnfs = new AaiResponse();
 
-               assertThat(actualResponse).isEqualTo(expectedResponse);
-       }
+        when(aaiClient.getVNFData(GLOBAL_SUBSCRIBER_ID, SERVICE_TYPE)).thenReturn(aaiResponseGetVnfResponse);
+        when(aaiClient.getVNFData(GLOBAL_SUBSCRIBER_ID_NULL_RESPONSE, SERVICE_TYPE)).thenReturn(null);
 
-       @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);
+        AaiResponse<AaiGetVnfResponse> actualResponseWithReturnedVnfs =
+            aaiService.getVNFData(GLOBAL_SUBSCRIBER_ID, SERVICE_TYPE);
+        AaiResponse<AaiGetVnfResponse> actualResponseWithoutReturnedVnfs =
+            aaiService.getVNFData(GLOBAL_SUBSCRIBER_ID_NULL_RESPONSE, SERVICE_TYPE);
 
-               GetServiceModelsByDistributionStatusResponse serviceModels = new GetServiceModelsByDistributionStatusResponse();
-               serviceModels.setResults(results);
+        assertThat(actualResponseWithReturnedVnfs)
+            .isEqualToComparingFieldByFieldRecursively(expectedResponseWithReturnedVnfs);
+        assertThat(actualResponseWithoutReturnedVnfs)
+            .isEqualToComparingFieldByField(expectedResponseWithoutReturnedVnfs);
+    }
 
-               AaiResponse<GetServiceModelsByDistributionStatusResponse> serviceModelsByDistributionStatusResponse
-                               = new AaiResponse<>(serviceModels, null, HttpStatus.SC_OK);
+    @Test
+    public void shouldGetAaiZones() {
+        when(aaiClient.getAllAicZones()).thenReturn(aaiResponse);
 
-               Service[] expectedServices = {
-                               createService("MODEL_TYPE1", "1"),
-                               createService("", "2")
-               };
+        AaiResponse actualResponse = aaiService.getAaiZones();
 
-               when(aaiClient.getServiceModelsByDistributionStatus()).thenReturn(serviceModelsByDistributionStatusResponse);
-               Collection<Service> actualServices = aaiService.getServicesByDistributionStatus();
+        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(actualServices)
-                               .hasSize(2)
-                               .usingFieldByFieldElementComparator()
-                               .containsExactly(expectedServices);
-       }
+        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 shouldReturnEmptyListOfServices() {
-               AaiResponse<GetServiceModelsByDistributionStatusResponse> emptyResponse
-                               = new AaiResponse<>(null, null, HttpStatus.SC_OK);
+    @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.getServiceModelsByDistributionStatus()).thenReturn(emptyResponse);
-               Collection<Service> actualServices = aaiService.getServicesByDistributionStatus();
+        when(aaiClient.getInstanceGroupsByCloudRegion(anyString(), anyString(), anyString()))
+            .thenReturn(expectedResponse);
+        AaiResponse<AaiGetInstanceGroupsByCloudRegion> actualResponse =
+            aaiService.getInstanceGroupsByCloudRegion(anyString(), anyString(), anyString());
 
-               assertThat(actualServices).isEqualTo(Collections.EMPTY_LIST);
-       }
+        assertThat(actualResponse).isEqualTo(expectedResponse);
+    }
 
-       @Test
-       public void shouldGetServiceInstanceAssociatedPnfs() {
-               ServiceRelationships relationsList = createServiceRelationships();
-               LogicalLinkResponse logicalLinkResponse = new LogicalLinkResponse();
-               logicalLinkResponse.setRelationshipList(relationsList.getRelationshipList());
+    @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);
 
-               AaiResponse<LogicalLinkResponse> aaiResponseLogicalLinkResponse =
-                               new AaiResponse<>(logicalLinkResponse, null, HttpStatus.SC_OK);
-               AaiResponse<ServiceRelationships> aaiResponseServiceRelations =
-                               new AaiResponse<>(relationsList, null, HttpStatus.SC_OK);
+        GetServiceModelsByDistributionStatusResponse serviceModels = new GetServiceModelsByDistributionStatusResponse();
+        serviceModels.setResults(results);
 
-               when(aaiClient.getServiceInstance(anyString(), anyString(), anyString()))
-                               .thenReturn(aaiResponseServiceRelations);
-               when(aaiClient.getLogicalLink(anyString())).thenReturn(aaiResponseLogicalLinkResponse);
+        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);
 
-               List<String> expectedPnfs = Collections.singletonList(CORRECT_VALUE);
-               List<String> actualPnfs = aaiService.getServiceInstanceAssociatedPnfs(anyString(), anyString(), anyString());
+        when(aaiClient.getServiceModelsByDistributionStatus()).thenReturn(emptyResponse);
+        Collection<Service> actualServices = aaiService.getServicesByDistributionStatus();
 
-               assertThat(actualPnfs).isEqualTo(expectedPnfs);
-       }
+        assertThat(actualServices).isEqualTo(Collections.EMPTY_LIST);
+    }
 
-       @Test
-       public void shouldGetPortMirroringConfigData() {
-               AaiResponseTranslator.PortMirroringConfigData expectedData
-                               = mock(AaiResponseTranslator.PortMirroringConfigData.class);
+    @Test
+    public void shouldGetServiceInstanceAssociatedPnfs() {
+        ServiceRelationships relationsList = createServiceRelationships();
+        LogicalLinkResponse logicalLinkResponse = new LogicalLinkResponse();
+        logicalLinkResponse.setRelationshipList(relationsList.getRelationshipList());
 
-               when(aaiClient.getCloudRegionAndSourceByPortMirroringConfigurationId(anyString())).thenReturn(aaiResponseJsonNode);
-               when(aaiResponseTranslator.extractPortMirroringConfigData(aaiResponseJsonNode)).thenReturn(expectedData);
+        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);
 
-               AaiResponseTranslator.PortMirroringConfigData actualData = aaiService.getPortMirroringConfigData(anyString());
-               assertThat(actualData).isEqualTo(expectedData);
-       }
+        List<String> expectedPnfs = Collections.singletonList(CORRECT_VALUE);
+        List<String> actualPnfs = aaiService.getServiceInstanceAssociatedPnfs(anyString(), anyString(), anyString());
 
+        assertThat(actualPnfs).isEqualTo(expectedPnfs);
+    }
 
-       @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;
-       }
+    @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(), isNull(), eq(HttpMethod.GET), any(), anyBoolean()))
+            .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);
+        tree.setType(SERVICE_INSTANCE);
+        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.setKey(key);
+        prop.setValue(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;
+    }
 }