From 09762dc92a06fb885f7055796db390a3a1baa535 Mon Sep 17 00:00:00 2001 From: "Kotagiri, Ramprasad (rp5662)" Date: Fri, 7 Aug 2020 15:54:10 -0400 Subject: CCSDK DCAE dashboard feature changes Issue-ID: DCAEGEN2-1857 Issue-ID: DCAEGEN2-2074 Issue-ID: DCAEGEN2-2364 Change-Id: I97f5ec4599512ed848136971b11d4c2a137a4999 Signed-off-by: Kotagiri, Ramprasad (rp5662) --- .../ccsdk/api/controller/NbApiControllerTest.java | 818 +++++++++++++++++++++ .../controller/CloudifyControllerTest.java | 611 +++++++++++---- .../controller/CommonApiControllerTest.java | 791 -------------------- .../dashboard/controller/ConsulControllerTest.java | 145 +--- .../DeploymentHandlerControllerTest.java | 45 +- .../controller/InventoryControllerTest.java | 616 +++++----------- .../dashboard/model/ControllerOpsToolsTest.java | 44 -- .../dashboard/rest/CloudifyRestClientImplTest.java | 525 +++++++++++-- .../dashboard/rest/ConsulRestClientImplTest.java | 198 ++++- .../rest/DeploymentHandlerClientImplTest.java | 122 +-- .../rest/RestInventoryClientImplTest.java | 300 ++++---- 11 files changed, 2299 insertions(+), 1916 deletions(-) create mode 100644 ccsdk-app-common/src/test/java/org/onap/ccsdk/api/controller/NbApiControllerTest.java delete mode 100644 ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/CommonApiControllerTest.java delete mode 100644 ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/model/ControllerOpsToolsTest.java (limited to 'ccsdk-app-common/src/test/java/org') diff --git a/ccsdk-app-common/src/test/java/org/onap/ccsdk/api/controller/NbApiControllerTest.java b/ccsdk-app-common/src/test/java/org/onap/ccsdk/api/controller/NbApiControllerTest.java new file mode 100644 index 0000000..3c33bda --- /dev/null +++ b/ccsdk-app-common/src/test/java/org/onap/ccsdk/api/controller/NbApiControllerTest.java @@ -0,0 +1,818 @@ +/******************************************************************************* + * =============LICENSE_START========================================================= + * + * ================================================================================= + * Copyright (c) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + * + *******************************************************************************/ + +package org.onap.ccsdk.api.controller; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.when; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.TreeSet; +import java.util.stream.Stream; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Matchers; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.onap.ccsdk.dashboard.core.MockUser; +import org.onap.ccsdk.dashboard.core.MockitoTestSuite; +import org.onap.ccsdk.dashboard.exceptions.BadRequestException; +import org.onap.ccsdk.dashboard.exceptions.DeploymentNotFoundException; +import org.onap.ccsdk.dashboard.exceptions.DownstreamException; +import org.onap.ccsdk.dashboard.exceptions.ServerErrorException; +import org.onap.ccsdk.dashboard.exceptions.ServiceAlreadyExistsException; +import org.onap.ccsdk.dashboard.exceptions.inventory.BlueprintParseException; +import org.onap.ccsdk.dashboard.exceptions.inventory.ServiceTypeNotFoundException; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeployedTenant; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeployment; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeploymentList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyExecution; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyExecutionList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyExecutionRequest; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeInstanceId; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeInstanceIdList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifySecret; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyTenantList; +import org.onap.ccsdk.dashboard.model.consul.ConsulDeploymentHealth; +import org.onap.ccsdk.dashboard.model.consul.ConsulServiceHealth; +import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentInput; +import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentRequest; +import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentResponse; +import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentResponseLinks; +import org.onap.ccsdk.dashboard.model.inventory.Service; +import org.onap.ccsdk.dashboard.model.inventory.ServiceList; +import org.onap.ccsdk.dashboard.model.inventory.ServiceQueryParams; +import org.onap.ccsdk.dashboard.model.inventory.ServiceRef; +import org.onap.ccsdk.dashboard.model.inventory.ServiceRefList; +import org.onap.ccsdk.dashboard.model.inventory.ServiceType; +import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeList; +import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeQueryParams; +import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeRequest; +import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeSummary; +import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeSummaryList; +import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeUploadRequest; +import org.onap.ccsdk.dashboard.rest.CloudifyClient; +import org.onap.ccsdk.dashboard.rest.ConsulClient; +import org.onap.ccsdk.dashboard.rest.DeploymentHandlerClient; +import org.onap.ccsdk.dashboard.rest.InventoryClient; +import org.onap.portalsdk.core.domain.User; +import org.onap.portalsdk.core.util.CacheManager; +import org.powermock.modules.junit4.PowerMockRunner; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.web.client.HttpServerErrorException; +import org.springframework.web.client.HttpStatusCodeException; +import org.springframework.web.servlet.support.ServletUriComponentsBuilder; + +import com.fasterxml.jackson.core.JsonParseException; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonMappingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.datatype.jdk8.Jdk8Module; + +@RunWith(PowerMockRunner.class) +public class NbApiControllerTest extends MockitoTestSuite { + + @Mock + InventoryClient inventoryClient; + + @Mock + DeploymentHandlerClient deploymentHandlerClient; + + @Mock + CloudifyClient cfyClient; + + @Mock + ConsulClient consulClient; + + @Mock + ServletUriComponentsBuilder uriBuilder; + + @InjectMocks + NbApiController subject = new NbApiController(); + + private HttpStatusCodeException httpException = + new HttpServerErrorException(HttpStatus.BAD_GATEWAY); + + protected final ObjectMapper objectMapper = new ObjectMapper(); + + HttpServletRequest mockedRequest; + HttpServletResponse mockedResponse; + + MockUser mockUser = new MockUser(); + ServiceList deplList = null; + Service deplItem = null; + + + ServiceTypeSummary bpItem, bpItem2 = null; + ServiceTypeSummaryList bpList, bpList2 = null; + ServiceType bpItemFull = null; + ServiceTypeList bpItemFullList = null; + ServiceTypeRequest bpUploadItem = null; + + BadRequestException badReqError; + ServiceAlreadyExistsException srvcExistError; + ServerErrorException serverError; + DownstreamException downStrmError; + JsonProcessingException jsonError; + DeploymentNotFoundException notFoundError; + private ServiceTypeNotFoundException serviceTypeException = + new ServiceTypeNotFoundException("Invalid blueprint"); + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + objectMapper.registerModule(new Jdk8Module()); + getExpectedDeployments(); + getExpectedBueprints(); + createBpUploadItem(); + mockedRequest = getMockedRequest(); + mockedResponse = getMockedResponse(); + badReqError = new BadRequestException("bad request"); + srvcExistError = new ServiceAlreadyExistsException("service already exists"); + serverError = new ServerErrorException("Error occured in server"); + downStrmError = new DownstreamException("error occured in downstream"); + notFoundError = new DeploymentNotFoundException("item not found"); + CacheManager testCache = new CacheManager(); + subject.setCacheManager(testCache); + User user = mockUser.mockUser(); + user.setLoginId("tester"); + StringBuffer urlBuff = new StringBuffer(); + urlBuff.append("http://orcl.com"); + //Mockito.when(mockedRequest.getRemoteUser()).thenReturn("tester"); + Mockito.when(mockedRequest.getRequestURL()).thenReturn(urlBuff); + } + + public void getExpectedDeployments() + throws JsonParseException, JsonMappingException, IOException { + + deplItem = new Service("dcae_dtiapi_1902", null, "1552335532348", "1552335532348", null, + "dummyVnfId", null, "dummyVnfType", "dummyLocation", "dcae_dtiapi_1902", null); + Collection items = new ArrayList(); + items.add(deplItem); + + String pageLinks = + "{\"previousLink\":null,\"nextLink\":{\"rel\":\"next\",\"href\":\"https://invt.com:30123/dcae-services/?offset=25\"}}"; + ServiceList.PaginationLinks paginationLinks = + objectMapper.readValue(pageLinks, ServiceList.PaginationLinks.class); + int totalCount = 1; + deplList = new ServiceList(items, totalCount, paginationLinks); + + } + + public void getExpectedBueprints() + throws JsonParseException, JsonMappingException, IOException { + + /*bpItem = new ServiceTypeSummary.Builder().application("DCAE").component("dcae"). + typeName("xyz1731-helm-1906").owner("xyz1731").typeVersion(1906).build();*/ + + bpItem = new ServiceTypeSummary("xyz1730", "xyz1730-helm-1905", 1905, "DCAE", "dcae", "123-456-321", + "342343", true); + + bpItem2 = new ServiceTypeSummary("xyz1731", "xyz1731-helm-1906", 1906, "DCAE", "dcae", "123-456-789", + "342343", true); + bpItemFull = new ServiceType.Builder("xyz1731", "xyz1731-helm-1906", 1906, + "tosca_definitions_version: cloudify_dsl_1_3", "", "DCAE", "dcae").build(); + + Collection items = new ArrayList(); + items.add(bpItem); + + Collection items2 = new ArrayList(); + items2.add(bpItem2); + + String pageLinks2 = + "{\"previousLink\":null,\"nextLink\":{\"rel\":\"next\",\"href\":\"https://invt.com:30123/dcae-services/?offset=25\"}}"; + ServiceTypeSummaryList.PaginationLinks paginationLinks = + objectMapper.readValue(pageLinks2, ServiceTypeSummaryList.PaginationLinks.class); + int totalCount = 1; + bpList = new ServiceTypeSummaryList(items, totalCount, paginationLinks); + bpList2 = new ServiceTypeSummaryList(items2, totalCount, paginationLinks); + + } + + public void createBpUploadItem() { + bpUploadItem = ServiceTypeRequest.from(bpItemFull); + } + + @After + public void tearDown() throws Exception { + } + + @Test + public final void testCreateBlueprint() throws Exception { + String bpTemplate = "tosca_definitions_version: cloudify_dsl_1_3"; + ServiceTypeUploadRequest bpUploadReq = + new ServiceTypeUploadRequest("dcae_user", "mod1", 2008, bpTemplate, "DCAE", "dcae"); + + when(inventoryClient.addServiceType(Matchers.any())) + .thenThrow(BlueprintParseException.class).thenThrow(httpException) + .thenThrow(Exception.class).thenReturn(bpItemFull); + + //when(mockedRequest.getRequestURI()).thenReturn("https://invt-svc:8080/dcae-service-types"); + String actual = subject.createBlueprint(mockedRequest, mockedResponse, bpUploadReq, uriBuilder); + assertTrue(actual.contains("error")); + actual = subject.createBlueprint(mockedRequest, mockedResponse, bpUploadReq, uriBuilder); + assertTrue(actual.contains("error")); + actual = subject.createBlueprint(mockedRequest, mockedResponse, bpUploadReq, uriBuilder); + assertTrue(actual.contains("error")); + actual = subject.createBlueprint(mockedRequest, mockedResponse, bpUploadReq, uriBuilder); + assertTrue(actual.contains("xyz")); + } + + @Test + public final void testCreateBlueprint_badReq() throws Exception { + String bpTemplate = "tosca_definitions_version: cloudify_dsl_1_3"; + ServiceTypeUploadRequest bpUploadReq = + new ServiceTypeUploadRequest("dcae_user", "mod1", 2008, bpTemplate, "DCAE", ""); + + when(inventoryClient.addServiceType(Matchers.any())) + .thenThrow(BlueprintParseException.class).thenThrow(httpException) + .thenThrow(Exception.class).thenReturn(null); + + String actual = subject.createBlueprint(mockedRequest, mockedResponse, bpUploadReq, uriBuilder); + assertTrue(actual.contains("error")); + } + + @Test + public final void testQueryBlueprint() throws Exception { + + Optional optionBp = Optional.ofNullable(bpItemFull); + when(inventoryClient.getServiceType(Mockito.any())).thenReturn(optionBp).thenThrow(Exception.class); + + String actual = subject.queryBlueprint("123-343", mockedRequest, mockedResponse, uriBuilder); + assertTrue(actual.contains("xyz")); + + actual = subject.queryBlueprint("123-343", mockedRequest, mockedResponse, uriBuilder); + assertTrue(actual.contains("error")); + } + + @Test + public final void testGetTenants() throws Exception { + String tenantsList = + "{\"items\": [{\"id\": 1, \"name\": \"default_tenant\", \"dName\": \"default_tenant\" }, " + + "{\"id\": 2, \"name\": \"dyh1b1902\", \"dName\": \"dyh1b1902\"}], " + + "\"metadata\": {\"pagination\": {\"total\": 2, \"offset\": 0, \"size\": 0}}}"; + CloudifyTenantList sampleData = null; + try { + sampleData = objectMapper.readValue(tenantsList, CloudifyTenantList.class); + } catch (Exception e) { + } + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + + Mockito.when(cfyClient.getTenants()).thenReturn(sampleData); + + String tenantStr = subject.getTenants(mockedRequest); + assertTrue(tenantStr.contains("dyh1b")); + } + + @Test + public final void testGetBlueprintsByPage() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + String filterStr = "{\"owner\": \"xyz1730\", \"name\": \"xyz1730-helm-1905\", \"id\": \"123\"}"; + + mockedRequest.addParameter("filters", filterStr); + mockedRequest.addParameter("sort", "name"); + + Set userRoleSet = new HashSet(); + Set userApps = new TreeSet<>(); + userRoleSet.add("Standard User"); + userRoleSet.add("ECOMPC_DCAE_WRITE"); + userApps.add("dcae"); + + Mockito.when(mockedRequest.getAttribute("userRoles")).thenReturn(userRoleSet); + Mockito.when(mockedRequest.getAttribute("userApps")).thenReturn(userApps); + + Collection items = bpList.items; + Stream sampleStream1 = items.stream(); + Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1).thenThrow(Exception.class); + String result = subject.getBlueprintsByPage(mockedRequest, 1, 1, uriBuilder, mockedResponse); + assertTrue(result.contains("xyz")); + + result = subject.getBlueprintsByPage(mockedRequest, 1, 1, uriBuilder, mockedResponse); + assertTrue(result.contains("error")); + } + + @Test + public final void testGetBlueprintsByPage_sortByOwner() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + mockedRequest.addParameter("sort", "owner"); + + Set userRoleSet = new HashSet(); + Set userApps = new TreeSet<>(); + userRoleSet.add("Standard User"); + userRoleSet.add("ECOMPC_DCAE_WRITE"); + userApps.add("dcae"); + + Mockito.when(mockedRequest.getAttribute("userRoles")).thenReturn(userRoleSet); + Mockito.when(mockedRequest.getAttribute("userApps")).thenReturn(userApps); + + Collection items = bpList.items; + Stream sampleStream1 = items.stream(); + Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1).thenThrow(Exception.class); + String result = subject.getBlueprintsByPage(mockedRequest, 1, 1, uriBuilder, mockedResponse); + assertTrue(result.contains("xyz")); + + result = subject.getBlueprintsByPage(mockedRequest, 1, 1, uriBuilder, mockedResponse); + assertTrue(result.contains("error")); + } + + @Test + public final void testGetBlueprintsByPage_sortByTypeId() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + mockedRequest.addParameter("sort", "typeId"); + + Set userRoleSet = new HashSet(); + Set userApps = new TreeSet<>(); + userRoleSet.add("Standard User"); + userRoleSet.add("ECOMPC_DCAE_WRITE"); + userApps.add("dcae"); + + Mockito.when(mockedRequest.getAttribute("userRoles")).thenReturn(userRoleSet); + Mockito.when(mockedRequest.getAttribute("userApps")).thenReturn(userApps); + + Collection items = bpList.items; + Stream sampleStream1 = items.stream(); + Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1).thenThrow(Exception.class); + String result = subject.getBlueprintsByPage(mockedRequest, 1, 1, uriBuilder, mockedResponse); + assertTrue(result.contains("xyz")); + + result = subject.getBlueprintsByPage(mockedRequest, 1, 1, uriBuilder, mockedResponse); + assertTrue(result.contains("error")); + } + + @Test + public final void testGetBlueprintsByPage_sortByCreated() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + mockedRequest.addParameter("sort", "created"); + + Set userRoleSet = new HashSet(); + Set userApps = new TreeSet<>(); + userRoleSet.add("Standard User"); + userRoleSet.add("ECOMPC_DCAE_WRITE"); + userApps.add("dcae"); + + Mockito.when(mockedRequest.getAttribute("userRoles")).thenReturn(userRoleSet); + Mockito.when(mockedRequest.getAttribute("userApps")).thenReturn(userApps); + + Collection items = bpList.items; + Stream sampleStream1 = items.stream(); + Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1).thenThrow(Exception.class); + String result = subject.getBlueprintsByPage(mockedRequest, 1, 1, uriBuilder, mockedResponse); + assertTrue(result.contains("xyz")); + + result = subject.getBlueprintsByPage(mockedRequest, 1, 1, uriBuilder, mockedResponse); + assertTrue(result.contains("error")); + } + + @Test + public final void testGetBlueprintsByPage_sortByVersion() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + mockedRequest.addParameter("sort", "typeVersion"); + + Set userRoleSet = new HashSet(); + Set userApps = new TreeSet<>(); + userRoleSet.add("Standard User"); + userRoleSet.add("ECOMPC_DCAE_WRITE"); + userApps.add("dcae"); + + Mockito.when(mockedRequest.getAttribute("userRoles")).thenReturn(userRoleSet); + Mockito.when(mockedRequest.getAttribute("userApps")).thenReturn(userApps); + + Collection items = bpList.items; + Stream sampleStream1 = items.stream(); + Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1).thenThrow(Exception.class); + String result = subject.getBlueprintsByPage(mockedRequest, 1, 1, uriBuilder, mockedResponse); + assertTrue(result.contains("xyz")); + + result = subject.getBlueprintsByPage(mockedRequest, 1, 1, uriBuilder, mockedResponse); + assertTrue(result.contains("error")); + } + + @SuppressWarnings("unchecked") + @Test + public final void testGetDeployment() { + CloudifyDeployment cldDepl = new CloudifyDeployment("description", "blueprint_id", + "created_at", "updated_at", "id1", null, null, null, null, null, null, null, "tenant1"); + + List items = new ArrayList(); + items.add(cldDepl); + + CloudifyDeploymentList.Metadata.Pagination pageObj = + new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); + + CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); + + CloudifyDeploymentList cldDeplList = new CloudifyDeploymentList(items, metadata); + + when(cfyClient.getDeployment(Mockito.any())).thenReturn(cldDeplList).thenThrow(Exception.class); + + String actual = subject.getDeployment("id1", mockedRequest); + assertTrue(actual.contains("id1")); + + actual = subject.getDeployment("id1", mockedRequest); + assertTrue(actual.contains("error")); + } + + @Test + public final void testGetDeploymentsByPage() throws Exception { + CloudifyDeployment cldDepl = new CloudifyDeployment("description", "blueprint_id", + "created_at", "updated_at", "id1", null, null, null, null, null, null, null, "tenant1"); + + List items = new ArrayList(); + items.add(cldDepl); + + CloudifyDeploymentList.Metadata.Pagination pageObj = + new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); + + CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); + + CloudifyDeploymentList cldDeplList = new CloudifyDeploymentList(items, metadata); + + when(cfyClient.getDeploymentsWithFilter(Mockito.any())).thenReturn(items).thenThrow(Exception.class); + + String actual = subject.getDeploymentsByPage(mockedRequest, 1, 1, uriBuilder, mockedResponse); + assertTrue(actual.contains("id1")); + + actual = subject.getDeploymentsByPage(mockedRequest, 1, 1, uriBuilder, mockedResponse); + assertTrue(actual.contains("error")); + } + + @Test + public final void testGetDeploymentInputs() throws Exception { + CloudifyDeployment cldDepl = new CloudifyDeployment("description", "blueprint_id", + "created_at", "updated_at", "id1", null, null, null, null, null, null, null, "tenant1"); + + List items = new ArrayList(); + items.add(cldDepl); + + CloudifyDeploymentList.Metadata.Pagination pageObj = + new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); + + CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); + + CloudifyDeploymentList cldDeplList = new CloudifyDeploymentList(items, metadata); + + when(cfyClient.getDeploymentInputs(Mockito.any(), Mockito.any())).thenReturn(cldDeplList).thenThrow(httpException).thenThrow(Exception.class); + + String actual = subject.getDeploymentInputs("dep_id", "tenant1", mockedRequest); + assertTrue(actual.contains("id1")); + + actual = subject.getDeploymentInputs("dep_id", "tenant1", mockedRequest); + assertTrue(actual.contains("error")); + + actual = subject.getDeploymentInputs("dep_id", "tenant1", mockedRequest); + assertTrue(actual.contains("error")); + + } + + @Test + public final void testGetServicesForType() throws Exception { + String testTypeIds = "44234234"; + ServiceRef expectedSrvc = new ServiceRef("dcae_dtiapi_1902", "432423", "433434"); + Collection expectedSrvcIds = new ArrayList(); + expectedSrvcIds.add(expectedSrvc); + ServiceRefList expectedSrvcRefList = new ServiceRefList(expectedSrvcIds, 1); + + when(inventoryClient.getServicesForType(Matchers.any())) + .thenReturn(expectedSrvcRefList); + String actual = subject.getServicesForType(mockedRequest, testTypeIds); + assertTrue(actual.contains(testTypeIds)); + } + + @SuppressWarnings("unchecked") + @Test + public final void testCreateDeployment() throws Exception { + Map inputs = new HashMap<>(); + inputs.put("key1", "value1"); + inputs.put("key2", "value2"); + inputs.put("key3", "value3"); + inputs.put("key4", 100); + + DeploymentInput deployInput1 = new DeploymentInput("component1", "tag1", + "xyz1731-helm-1906", 1906, "blueprintId", inputs, "tenant1", + null, true, true, true, false, true, false); + + DeploymentInput deployInput2 = new DeploymentInput("component1", "tag1", + "xyz1731-helm-1906", 1906, null, inputs, "tenant1", + null, true, true, true, false, true, false); + + DeploymentResponseLinks expectLink = new DeploymentResponseLinks("self", "status"); + DeploymentResponse expectResp = new DeploymentResponse("req1", expectLink); + + Collection items = bpList2.items; + Stream sampleStream1 = items.stream(); + Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) + .thenReturn(sampleStream1); + +/* String actualResp0 = subject.createDeployment(mockedRequest, mockedResponse, deployInput2); + assertTrue(actualResp0.contains("error"));*/ + + Optional optionBp = Optional.ofNullable(bpItemFull); + Mockito.when(inventoryClient.getServiceType(Matchers.anyString())).thenReturn(optionBp); + + StringBuffer expectedStrBuff = new StringBuffer(); + expectedStrBuff.append("http://oom.s2.com"); + when(mockedRequest.getRequestURL()).thenReturn(expectedStrBuff); + + when(deploymentHandlerClient.putDeployment(Matchers.anyString(), Matchers.anyString(), + Matchers.any())).thenReturn(expectResp).thenReturn(expectResp) + .thenThrow(badReqError) + .thenThrow(srvcExistError).thenThrow(serverError).thenThrow(downStrmError) + .thenThrow(Exception.class); + + String actualResp = subject.createDeployment(mockedRequest, mockedResponse, deployInput1); + assertTrue(actualResp.contains("component1")); + + actualResp = subject.createDeployment(mockedRequest, mockedResponse, deployInput2); + assertTrue(actualResp.contains("component1")); + + actualResp = subject.createDeployment(mockedRequest, mockedResponse, deployInput1); + assertTrue(actualResp.contains("error")); + + actualResp = subject.createDeployment(mockedRequest, mockedResponse, deployInput1); + assertTrue(actualResp.contains("error")); + + actualResp = subject.createDeployment(mockedRequest, mockedResponse, deployInput1); + assertTrue(actualResp.contains("error")); + + actualResp = subject.createDeployment(mockedRequest, mockedResponse, deployInput1); + assertTrue(actualResp.contains("error")); + + actualResp = subject.createDeployment(mockedRequest, mockedResponse, deployInput1); + assertTrue(actualResp.contains("error")); + + } + + @Test + public final void testGetExecutionByDeploymentId() throws Exception { + CloudifyExecution cldExecution = + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); + + List cldExecutionList = new ArrayList(); + + cldExecutionList.add(cldExecution); + + CloudifyExecutionList cloudifyExecutionList = + new CloudifyExecutionList(cldExecutionList, null); + + when(cfyClient.getExecutionsSummary(Mockito.any(), Mockito.any())) + .thenReturn(cloudifyExecutionList).thenThrow(httpException).thenThrow(Exception.class);; + + String actual = subject.getExecutionByDeploymentId("deploymentId", "tenant", mockedRequest); + assertTrue(actual.contains("execution_id1")); + + actual = subject.getExecutionByDeploymentId("deploymentId", "tenant", mockedRequest); + assertTrue(actual.contains("error")); + + actual = subject.getExecutionByDeploymentId("deploymentId", "tenant", mockedRequest); + assertTrue(actual.contains("error")); + + } + + @Test + public final void testGetServiceHealthByDeploymentId() throws Exception { + String[] svcTags = {"cfytenantname=onap"}; + ConsulServiceHealth consulSrvcHlth = new ConsulServiceHealth("cjlvmcnsl00", + "service:pgaas1_Service_ID", "Service 'pgaasServer1' check", "passing", + "This is a pgaas1_Service_ID health check", + "HTTP GET http://srvc.com:8000/healthcheck/status: 200 OK Output: { \"output\": \"Thu Apr 20 19:53:01 UTC 2017|INFO|masters=1 pgaas1.com|secondaries=0 |maintenance= |down=1 pgaas2.com| \" }\n", + "pgaas1_Service_ID", "pgaasServer1", svcTags, 190199, 199395); + + ConsulDeploymentHealth cnslDeployHlth = + new ConsulDeploymentHealth.Builder(consulSrvcHlth).build(); + + when(consulClient.getServiceHealthByDeploymentId(Mockito.any())).thenReturn(cnslDeployHlth) + .thenThrow(httpException).thenThrow(Exception.class); + + String actual = subject.getServiceHealthByDeploymentId("deploymentId", mockedRequest); + assertTrue(actual.contains("cjlvmcnsl00")); + + actual = subject.getServiceHealthByDeploymentId("deploymentId", mockedRequest); + assertTrue(actual.contains("error")); + + actual = subject.getServiceHealthByDeploymentId("deploymentId", mockedRequest); + assertTrue(actual.contains("error")); + } + + @Test + public final void testDeleteBlueprint() throws Exception { + //String expected = "{\"202\": \"OK\"}"; + String expected = "{\"204\": \"Blueprint deleted\"}"; + List deplForBp = new ArrayList<>(); + deplForBp.clear(); + Mockito.when(cfyClient.getDeploymentForBlueprint(Matchers.any())) + .thenReturn(deplForBp); + + Optional optionBp = Optional.ofNullable(bpItemFull); + Mockito.when(inventoryClient.getServiceType(Matchers.anyString())).thenReturn(optionBp); + + List srvcRefList = new ArrayList<>(); + srvcRefList.clear(); + int itemCnt = 0; + ServiceRefList mockSvcRefList = new ServiceRefList(srvcRefList, itemCnt); + + Mockito.when(inventoryClient.getServicesForType(Matchers.any())) + .thenReturn(mockSvcRefList); + + doNothing().doThrow(serviceTypeException).doThrow(Exception.class).when(inventoryClient) + .deleteServiceType(Matchers.anyString()); + + String actual = subject.deleteBlueprint("srvcId", mockedRequest, mockedResponse, uriBuilder); + assertEquals(expected, actual); + + actual = subject.deleteBlueprint("srvcId", mockedRequest, mockedResponse, uriBuilder); + assertTrue(actual.contains("error")); + + actual = subject.deleteBlueprint("srvcId", mockedRequest, mockedResponse, uriBuilder); + assertTrue(actual.contains("error")); + } + + @Test + public final void testDeleteBlueprint_withDepl() throws Exception { + CloudifyDeployedTenant mockCfyDeplTen = + new CloudifyDeployedTenant("id1", "tenant", "45435435", "54543534"); + + Optional optionBp = Optional.ofNullable(bpItemFull); + Mockito.when(inventoryClient.getServiceType(Matchers.anyString())).thenReturn(optionBp); + + List deplForBp = new ArrayList<>(); + deplForBp.add(mockCfyDeplTen); + Mockito.when(cfyClient.getDeploymentForBlueprint(Matchers.any())) + .thenReturn(deplForBp); + + String actual = subject.deleteBlueprint("srvcId", mockedRequest, mockedResponse, uriBuilder); + assertTrue(actual.contains("error")); + } + + @Test + public final void testDeleteDeployment() throws Exception { + CloudifyDeployment cldDepl = new CloudifyDeployment("description", "blueprint_id", + "created_at", "updated_at", "dcae_dep_id", null, null, null, null, null, null, null, "tenant1"); + + List items = new ArrayList(); + items.add(cldDepl); + + CloudifyDeploymentList.Metadata.Pagination pageObj = + new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); + + CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); + + CloudifyDeploymentList cldDeplList = new CloudifyDeploymentList(items, metadata); + + Mockito.when(cfyClient.getDeployment(Matchers.anyString(), Matchers.anyString())).thenReturn(cldDeplList); + + doNothing().doThrow(badReqError).doThrow(serverError).doThrow(downStrmError) + .doThrow(notFoundError).doThrow(Exception.class).when(deploymentHandlerClient) + .deleteDeployment(Matchers.anyString(), Matchers.anyString()); + + String actual = subject.deleteDeployment("dcae_dep_id", mockedRequest, "tenant1", mockedResponse); + assertTrue(actual.contains("dcae_dep_id")); + + actual = subject.deleteDeployment("dcae_dep_id", mockedRequest, "tenant1", mockedResponse); + assertTrue(actual.contains("error")); + + actual = subject.deleteDeployment("dcae_dep_id", mockedRequest, "tenant1", mockedResponse); + assertTrue(actual.contains("error")); + + actual = subject.deleteDeployment("dcae_dep_id", mockedRequest, "tenant1", mockedResponse); + assertTrue(actual.contains("error")); + + actual = subject.deleteDeployment("dcae_dep_id", mockedRequest, "tenant1", mockedResponse); + assertTrue(actual.contains("error")); + + actual = subject.deleteDeployment("dcae_dep_id", mockedRequest, "tenant1", mockedResponse); + assertTrue(actual.contains("error")); + + } + + @SuppressWarnings("unchecked") + @Test + public void testCancelExecution() throws Exception { + List tenants = new ArrayList(); + tenants.add("tenant1"); + + HttpHeaders httpHeader = new HttpHeaders(); + httpHeader.put("tenant", tenants); + + CloudifyExecution cfyExecObj = + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); + + when(cfyClient.cancelExecution(Mockito.any(), Mockito.any(), Mockito.any())) + .thenReturn(cfyExecObj).thenThrow(Exception.class).thenThrow(httpException); + + String actualResult = + subject.cancelExecution(httpHeader, "id1", null, mockedRequest, mockedResponse); + assertTrue(actualResult.contains("execution_id1")); + + actualResult = + subject.cancelExecution(httpHeader, "id1", null, mockedRequest, mockedResponse); + assertTrue(actualResult.contains("error")); + + actualResult = + subject.cancelExecution(httpHeader, "id1", null, mockedRequest, mockedResponse); + assertTrue(actualResult.contains("error")); + } + + @SuppressWarnings("unchecked") + @Test + public final void testModifyDeployment() throws Exception { + CloudifyExecution cldExecution = + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); + + Map params = new HashMap(); + params.put("tenant", "tenant1"); + params.put("workflow", "upgrade"); + + CloudifyExecutionRequest cfyExecReq = new CloudifyExecutionRequest("deployment_id", + "upgrade", false, false, "tenant1", params); + + CloudifyNodeInstanceId cfyNodeInst = new CloudifyNodeInstanceId("node_instance_id1"); + + List cfyNodeInstItems = new ArrayList(); + + cfyNodeInstItems.add(cfyNodeInst); + + CloudifyNodeInstanceIdList cfyNodeInstList = + new CloudifyNodeInstanceIdList(cfyNodeInstItems, null); + + when(cfyClient.getNodeInstanceId(Mockito.any(), Mockito.any())).thenReturn(cfyNodeInstList); + + String secretTokenStr = + "{\"created_at\": \"created_ts\", \"key\": \"acl_key\", \"updated_at\": \"updated_ts\", \"value\": \"acl_token_val\", \"visibility\": \"global\", \"is_hidden_value\": \"false\", \"tenant_name\": \"tenant\", \"resource_availability\": \"rsrc\"}"; + CloudifySecret secretData = null; + try { + secretData = objectMapper.readValue(secretTokenStr, CloudifySecret.class); + } catch (Exception e) { + + } + when(cfyClient.getSecret(Mockito.any(), Mockito.any())).thenReturn(secretData); + when(cfyClient.startExecution(Matchers.any())) + .thenReturn(cldExecution).thenThrow(Exception.class).thenThrow(httpException); + + String inputParamStr = "{\"tenant\": \"tenant1\", \"workflow\":\"upgrade\"}"; + + InputStream is1 = new ByteArrayInputStream(inputParamStr.getBytes()); + String actualResult = subject.modifyDeployment("depId", mockedRequest, is1); + assertTrue(actualResult.contains("execution_id1")); + + InputStream is2 = new ByteArrayInputStream(inputParamStr.getBytes()); + actualResult = subject.modifyDeployment("depId", mockedRequest, is2); + assertTrue(actualResult.contains("error")); + + InputStream is3 = new ByteArrayInputStream(inputParamStr.getBytes()); + actualResult = subject.modifyDeployment("depId", mockedRequest, is3); + assertTrue(actualResult.contains("error")); + + } + +} diff --git a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/CloudifyControllerTest.java b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/CloudifyControllerTest.java index d6e1fb0..d88e530 100644 --- a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/CloudifyControllerTest.java +++ b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/CloudifyControllerTest.java @@ -22,16 +22,22 @@ package org.onap.ccsdk.dashboard.controller; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.when; import java.util.ArrayList; +import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.InjectMocks; import org.mockito.Matchers; import org.mockito.Mock; @@ -39,39 +45,51 @@ import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.onap.ccsdk.dashboard.core.MockUser; import org.onap.ccsdk.dashboard.core.MockitoTestSuite; -import org.onap.ccsdk.dashboard.model.CloudifyBlueprint; -import org.onap.ccsdk.dashboard.model.CloudifyBlueprintList; -import org.onap.ccsdk.dashboard.model.CloudifyDeployedTenant; -import org.onap.ccsdk.dashboard.model.CloudifyDeployedTenantList; -import org.onap.ccsdk.dashboard.model.CloudifyDeployment; -import org.onap.ccsdk.dashboard.model.CloudifyDeploymentList; -import org.onap.ccsdk.dashboard.model.CloudifyDeploymentUpdateRequest; -import org.onap.ccsdk.dashboard.model.CloudifyDeploymentUpdateResponse; -import org.onap.ccsdk.dashboard.model.CloudifyEvent; -import org.onap.ccsdk.dashboard.model.CloudifyEventList; -import org.onap.ccsdk.dashboard.model.CloudifyExecution; -import org.onap.ccsdk.dashboard.model.CloudifyExecutionList; -import org.onap.ccsdk.dashboard.model.CloudifyExecutionRequest; -import org.onap.ccsdk.dashboard.model.CloudifyNodeInstance; -import org.onap.ccsdk.dashboard.model.CloudifyNodeInstanceId; -import org.onap.ccsdk.dashboard.model.CloudifyNodeInstanceIdList; -import org.onap.ccsdk.dashboard.model.CloudifyNodeInstanceList; -import org.onap.ccsdk.dashboard.model.CloudifyTenant; -import org.onap.ccsdk.dashboard.model.CloudifyTenantList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyBlueprint; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyBlueprintList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeployedTenant; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeployment; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeploymentExt; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeploymentHelm; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeploymentList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyEvent; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyEventList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyExecution; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyExecutionList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyExecutionRequest; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeInstance; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeInstanceId; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeInstanceIdList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeInstanceList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyPlugin; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyPluginList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifySecret; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyTenantList; +import org.onap.ccsdk.dashboard.model.inventory.ServiceQueryParams; +import org.onap.ccsdk.dashboard.model.inventory.ServiceRef; +import org.onap.ccsdk.dashboard.model.inventory.ServiceRefList; import org.onap.ccsdk.dashboard.rest.CloudifyClient; +import org.onap.ccsdk.dashboard.rest.InventoryClient; import org.onap.portalsdk.core.domain.User; +import org.onap.portalsdk.core.util.CacheManager; import org.onap.portalsdk.core.web.support.UserUtils; +import org.powermock.modules.junit4.PowerMockRunner; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpStatus; import org.springframework.web.client.HttpClientErrorException; +import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.datatype.jdk8.Jdk8Module; +@RunWith(PowerMockRunner.class) public class CloudifyControllerTest extends MockitoTestSuite { @Mock private CloudifyClient restClient; + + @Mock + private InventoryClient invClient; @InjectMocks private CloudifyController subject = new CloudifyController(); @@ -93,6 +111,8 @@ public class CloudifyControllerTest extends MockitoTestSuite { MockitoAnnotations.initMocks(this); objectMapper.registerModule(new Jdk8Module()); httpException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "statusText"); + CacheManager testCache = new CacheManager(); + subject.setCacheManager(testCache); } @SuppressWarnings("unchecked") @@ -125,6 +145,409 @@ public class CloudifyControllerTest extends MockitoTestSuite { assertTrue(tenantStr.contains("error")); } + @Test + public final void testGetAllServiceNames() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + //mockedRequest.addParameter("searchBy", "xyz"); + mockedRequest.addParameter("sortBy", "owner"); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); + + CloudifyDeployment cldDepl = new CloudifyDeployment("description", "blueprint_id", + "created_at", "updated_at", "id1", null, null, null, null, null, null, null, "tenant1"); + + List items = new ArrayList(); + items.add(cldDepl); + + CloudifyDeploymentList.Metadata.Pagination pageObj = + new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); + + CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); + + CloudifyDeploymentList cldDeplList = new CloudifyDeploymentList(items, metadata); + + Mockito.when(restClient.getDeployments( + Mockito.any(),Mockito.anyInt(), Mockito.anyInt(), Mockito.anyBoolean())) + .thenReturn(items); + + String actual = subject.getAllServiceNames(mockedRequest); + assertTrue(actual.contains("id1")); + } + @Test + public final void testGetDeploymentsByPage() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + mockedRequest.addParameter("searchBy", "tenant:default_tenant;cache:false;serviceRef:id1"); + mockedRequest.addParameter("sortBy", "owner"); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); + + CloudifyDeployment cldDepl = new CloudifyDeployment("description", "blueprint_id", + "created_at", "updated_at", "id1", null, null, null, null, null, null, null, "tenant1"); + + List items = new ArrayList(); + items.add(cldDepl); + + CloudifyDeploymentList.Metadata.Pagination pageObj = + new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); + + CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); + + CloudifyDeploymentList cldDeplList = new CloudifyDeploymentList(items, metadata); + + Mockito.when(restClient.getDeployments( + Mockito.any(),Mockito.anyInt(), Mockito.anyInt(), Mockito.anyBoolean(), Mockito.anyBoolean())) + .thenReturn(items); + List cfyDepExList = + new ArrayList(); + List cfyDeplHelmList = + new ArrayList(); + + Mockito.when(restClient.updateWorkflowStatus(Mockito.any())). + thenReturn(cfyDepExList); + Mockito.when(restClient.updateHelmInfo(Mockito.any())). + thenReturn(cfyDeplHelmList); + + String actual = subject.getDeploymentsByPage(mockedRequest); + assertTrue(actual.contains("id1")); + } + + @Test + public final void testViewBlueprintContentById() throws Exception { + byte[] result = "sample blueprint yaml content".getBytes(); + + when(restClient.viewBlueprint(Mockito.any(), Mockito.any())).thenReturn(result); + + byte[] actual = subject.viewBlueprintContentById("id", "tenant", mockedRequest); + assertArrayEquals(result, actual); + } + + @Test + public final void testGetDepCount() throws Exception { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + //mockedRequest.addParameter("searchBy", "xyz"); + mockedRequest.addParameter("sortBy", "owner"); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); + + CloudifyDeployment cldDepl = new CloudifyDeployment("description", "blueprint_id", + "created_at", "updated_at", "id1", null, null, null, null, null, null, null, "tenant1"); + + List items = new ArrayList(); + items.add(cldDepl); + + CloudifyDeploymentList.Metadata.Pagination pageObj = + new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); + + CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); + + CloudifyDeploymentList cldDeplList = new CloudifyDeploymentList(items, metadata); + + Mockito.when(restClient.getDeploymentsWithFilter(Mockito.any())) + .thenReturn(items); + + String actual = subject.getDepCount(mockedRequest); + assertTrue(actual.contains("items")); + } + + @Test + public final void testGetPluginCount() throws JsonProcessingException { + CloudifyPlugin sampleData = + new CloudifyPlugin("plugin1", "202001", "linux", "linux_k8s_plugin", "20200801"); + + List cfyPlugins = new ArrayList(); + cfyPlugins.add(sampleData); + + CloudifyPluginList.Metadata.Pagination pageObj = + new CloudifyPluginList.Metadata.Pagination(1, 0, 1); + CloudifyPluginList.Metadata metadata = new CloudifyPluginList.Metadata(pageObj); + + CloudifyPluginList cfyPluginList = new CloudifyPluginList(cfyPlugins, metadata); + + when(restClient.getPlugins()).thenReturn(cfyPluginList); + String actual = subject.getPluginCount(mockedRequest); + assertTrue(actual.contains("1")); + } + + @Test + public final void testDeleteBlueprint() throws Exception { + String json = "{\"202\": \"OK\"}"; + + doNothing().doThrow(httpException).doThrow(Exception.class).when(restClient).deleteBlueprint(Mockito.any(), Mockito.any()); + + String actual = subject.deleteBlueprint("id", "tenant", mockedRequest, mockedResponse); + assertTrue(actual.equals(json)); + + actual = subject.deleteBlueprint("id", "tenant", mockedRequest, mockedResponse); + assertTrue(actual.contains("error")); + + actual = subject.deleteBlueprint("id", "tenant", mockedRequest, mockedResponse); + assertTrue(actual.contains("error")); + } + + @Test + public final void testGetDeploymentsForType() throws Exception { + String[] testTypeIds = {"44234234"}; + ServiceRef expectedSrvc = new ServiceRef("dcae_dtiapi_1902", "432423", "433434"); + Collection expectedSrvcIds = new ArrayList(); + expectedSrvcIds.add(expectedSrvc); + ServiceRefList expectedSrvcRefList = new ServiceRefList(expectedSrvcIds, 1); + + CloudifyDeployedTenant cfyDepTen = + new CloudifyDeployedTenant("id", "tenant_name", "created_at", "updated_at"); + + List cfyDeplTenList = new ArrayList<>(); + cfyDeplTenList.add(cfyDepTen); + + when(restClient.getDeploymentForBlueprint(Mockito.any())).thenReturn(cfyDeplTenList); + + when(invClient.getServicesForType(Matchers.any())) + .thenReturn(expectedSrvcRefList); + String actual = subject.getDeploymentsForType(mockedRequest, testTypeIds); + assertTrue(actual.contains(testTypeIds[0])); + } + + @Test + @Ignore + public final void testCacheOwnerDeployMap() { + + } + + @Test + public final void testGetExecutionsPerTenant() throws Exception { + String tenantsList = + "{\"items\": [{\"id\": 1, \"name\": \"default_tenant\", \"dName\": \"default_tenant\" }, " + + "{\"id\": 2, \"name\": \"dyh1b1902\", \"dName\": \"dyh1b1902\"}], " + + "\"metadata\": {\"pagination\": {\"total\": 2, \"offset\": 0, \"size\": 0}}}"; + CloudifyTenantList tenantData = null; + try { + tenantData = objectMapper.readValue(tenantsList, CloudifyTenantList.class); + } catch (Exception e) { + } + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + Mockito.when(restClient.getTenants()).thenReturn(tenantData); + + CloudifyExecution cldExecution = + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); + + List cldExecutionList = new ArrayList(); + + cldExecutionList.add(cldExecution); + + CloudifyExecutionList cloudifyExecutionList = + new CloudifyExecutionList(cldExecutionList, null); + + when(restClient.getExecutionsSummaryPerTenant(Mockito.any())) + .thenReturn(cloudifyExecutionList).thenReturn(cloudifyExecutionList) + .thenReturn(cloudifyExecutionList); + + String actual = subject.getExecutionsPerTenant(mockedRequest, "default_tenant", "failed"); + assertFalse(actual.contains("execution_id1")); + actual = subject.getExecutionsPerTenant(mockedRequest, "default_tenant", "successful"); + assertTrue(actual.contains("execution_id1")); + actual = subject.getExecutionsPerTenant(mockedRequest, null, "successful"); + assertTrue(actual.contains("execution_id1")); + } + + @Test + public final void testGetExecutionsPerTenant_error() throws Exception { + String tenantsList = + "{\"items\": [{\"id\": 1, \"name\": \"default_tenant\", \"dName\": \"default_tenant\" }, " + + "{\"id\": 2, \"name\": \"dyh1b1902\", \"dName\": \"dyh1b1902\"}], " + + "\"metadata\": {\"pagination\": {\"total\": 2, \"offset\": 0, \"size\": 0}}}"; + CloudifyTenantList tenantData = null; + try { + tenantData = objectMapper.readValue(tenantsList, CloudifyTenantList.class); + } catch (Exception e) { + } + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + Mockito.when(restClient.getTenants()).thenReturn(tenantData); + + CloudifyExecution cldExecution = + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); + + List cldExecutionList = new ArrayList(); + + cldExecutionList.add(cldExecution); + + CloudifyExecutionList cloudifyExecutionList = + new CloudifyExecutionList(cldExecutionList, null); + + when(restClient.getExecutionsSummaryPerTenant(Mockito.any())) + .thenThrow(Exception.class).thenThrow(Exception.class).thenThrow(Exception.class); + + String actual = subject.getExecutionsPerTenant(mockedRequest, "default_tenant", "failed"); + assertTrue(actual.contains("error")); + + actual = subject.getExecutionsPerTenant(mockedRequest, "default_tenant", "successful"); + assertTrue(actual.contains("error")); + + actual = subject.getExecutionsPerTenant(mockedRequest, null, "failed"); + assertTrue(actual.contains("error")); + } + + @Test + public final void testQueryExecution() throws Exception { + CloudifyExecution cldExecution = + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); + List cldExecutionList = new ArrayList(); + cldExecutionList.add(cldExecution); + + when(restClient.getExecutionIdSummary( + Mockito.any(), Mockito.any())).thenReturn(cldExecution); + + String actual = subject.queryExecution("id", "tenant", mockedRequest); + assertTrue(actual.contains("items")); + } + + @SuppressWarnings("unchecked") + @Test + public final void testGetActiveExecutions() throws Exception { + String tenantsList = + "{\"items\": [{\"id\": 1, \"name\": \"default_tenant\", \"dName\": \"default_tenant\" }, " + + "{\"id\": 2, \"name\": \"dyh1b1902\", \"dName\": \"dyh1b1902\"}], " + + "\"metadata\": {\"pagination\": {\"total\": 2, \"offset\": 0, \"size\": 0}}}"; + CloudifyTenantList tenantData = null; + try { + tenantData = objectMapper.readValue(tenantsList, CloudifyTenantList.class); + } catch (Exception e) { + } + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + Mockito.when(restClient.getTenants()).thenReturn(tenantData).thenThrow(Exception.class); + + CloudifyExecution cldExecution = + new CloudifyExecution("started", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); + + List cldExecutionList = new ArrayList(); + + cldExecutionList.add(cldExecution); + + CloudifyExecutionList cloudifyExecutionList = + new CloudifyExecutionList(cldExecutionList, null); + + when(restClient.getExecutionsSummaryPerTenant(Mockito.any())) + .thenReturn(cloudifyExecutionList).thenReturn(cloudifyExecutionList); + + String actual = subject.getActiveExecutions(mockedRequest); + assertTrue(actual.contains("execution_id1")); + actual = subject.getActiveExecutions(mockedRequest); + assertTrue(actual.contains("error")); + + } + + @Test + public final void testGetNodeInstanceDetails() throws Exception { + + Map runtime_properties = + new HashMap<>(); + runtime_properties.put("key1", "value1"); + + CloudifyNodeInstance cfyNodeInst = + new CloudifyNodeInstance("node_instance_id1", runtime_properties); + + List cfyNodeInstItems = new ArrayList(); + + cfyNodeInstItems.add(cfyNodeInst); + + CloudifyNodeInstanceList cfyNodeInstList = + new CloudifyNodeInstanceList(cfyNodeInstItems, null); + + when(restClient.getNodeInstanceDetails(Mockito.any(), Mockito.any())). + thenReturn(cfyNodeInstList).thenThrow(httpException). + thenThrow(Exception.class); + + String actual = + subject.getNodeInstanceDetails("deploymentId", "tenant", mockedRequest); + assertTrue(actual.contains("node_instance_id1")); + + actual = + subject.getNodeInstanceDetails("deploymentId", "tenant", mockedRequest); + assertTrue(actual.contains("error")); + + actual = + subject.getNodeInstanceDetails("deploymentId", "tenant", mockedRequest); + assertTrue(actual.contains("error")); + } + + @Test + public final void testGetNodeInstances() throws Exception { + CloudifyNodeInstanceId cfyNodeInst = new CloudifyNodeInstanceId("node_instance_id1"); + + List cfyNodeInstItems = new ArrayList(); + + cfyNodeInstItems.add(cfyNodeInst); + + CloudifyNodeInstanceIdList cfyNodeInstList = + new CloudifyNodeInstanceIdList(cfyNodeInstItems, null); + + when(restClient.getNodeInstances(Mockito.any(), Mockito.any())). + thenReturn(cfyNodeInstList).thenThrow(httpException). + thenThrow(Exception.class); + + String actual = + subject.getNodeInstances("deploymentId", "tenant", mockedRequest); + assertTrue(actual.contains("node_instance_id1")); + + actual = + subject.getNodeInstances("deploymentId", "tenant", mockedRequest); + assertTrue(actual.contains("error")); + + actual = + subject.getNodeInstances("deploymentId", "tenant", mockedRequest); + assertTrue(actual.contains("error")); + } + + @Test + public final void testGetPlugins() throws Exception { + CloudifyPlugin sampleData = + new CloudifyPlugin("plugin1", "202001", "linux", "linux_k8s_plugin", "20200801"); + + List cfyPlugins = new ArrayList(); + cfyPlugins.add(sampleData); + + CloudifyPluginList.Metadata.Pagination pageObj = + new CloudifyPluginList.Metadata.Pagination(1, 0, 1); + CloudifyPluginList.Metadata metadata = new CloudifyPluginList.Metadata(pageObj); + + CloudifyPluginList cfyPluginList = new CloudifyPluginList(cfyPlugins, metadata); + + when(restClient.getPlugins()).thenReturn(cfyPluginList).thenThrow(Exception.class); + String actual = subject.getPlugins(mockedRequest); + assertTrue(actual.contains("plugin1")); + + actual = subject.getPlugins(mockedRequest); + assertTrue(actual.contains("error")); + } + + @Test + @Ignore + public final void testGetSecrets() { + + } + + @Test + @Ignore + public final void testGetSecret() { + + } + + @Test + @Ignore + public final void testDeleteSecret() { + + } + + @Test + @Ignore + public final void testCreateSecret() { + } + @SuppressWarnings({"unchecked", "unchecked"}) @Test public final void testGetBlueprintById() throws Exception { @@ -196,93 +619,13 @@ public class CloudifyControllerTest extends MockitoTestSuite { actualResult = subject.getDeploymentById("id1", null, mockedRequest); assertTrue(actualResult.contains("error")); } - - @SuppressWarnings("unchecked") - @Test - public void testGetTenantStatusForService() throws Exception { - - String[] deplIds = {"id1", "id2"}; - - CloudifyDeployedTenant cldDeplTenant = new CloudifyDeployedTenant("id1", "bp1", "tenant1"); - - List cldDeplTenantList = new ArrayList(); - - cldDeplTenantList.add(cldDeplTenant); - - CloudifyDeployedTenantList cldDeployedTenantList = - new CloudifyDeployedTenantList(cldDeplTenantList, null); - - CloudifyTenant cldTenant = new CloudifyTenant("tenant1", "tenant1", "tenant_id1"); - - List cldfyTenantList = new ArrayList(); - cldfyTenantList.add(cldTenant); - - CloudifyTenantList cloudifyTenantList = new CloudifyTenantList(cldfyTenantList, null); - - CloudifyExecution cldExecution = - new CloudifyExecution("successful", "created_at", "install", false, "bp1", "id1", - "tenant1", "error", "execution_id1", null, false, false); - - List cldExecutionList = new ArrayList(); - - cldExecutionList.add(cldExecution); - - CloudifyExecutionList cloudifyExecutionList = - new CloudifyExecutionList(cldExecutionList, null); - - Map plan = new HashMap(); - HashMap plugins_to_install = new HashMap(); - plugins_to_install.put("name", "helm-plugin"); - ArrayList> deployment_plugins_to_install = - new ArrayList>(); - - deployment_plugins_to_install.add(plugins_to_install); - plan.put("deployment_plugins_to_install", deployment_plugins_to_install); - - Map workflows = new HashMap(); - workflows.put("status", "workflowshelm"); - plan.put("workflows", workflows); - - CloudifyBlueprint cldBp = - new CloudifyBlueprint("file1", "description1", "343242", "3423423", "id1", plan); - - List items = new ArrayList(); - items.add(cldBp); - - CloudifyBlueprintList.Metadata.Pagination pageObj = - new CloudifyBlueprintList.Metadata.Pagination(1, 0, 1); - - CloudifyBlueprintList.Metadata metadata = new CloudifyBlueprintList.Metadata(pageObj); - - CloudifyBlueprintList cldBpList = new CloudifyBlueprintList(items, metadata); - - when(restClient.getTenants()).thenReturn(cloudifyTenantList); - - when(restClient.getTenantInfoFromDeploy(Mockito.any())).thenReturn(cldDeployedTenantList); - - when(restClient.getExecutionsSummary(Mockito.any(), Mockito.any())) - .thenReturn(cloudifyExecutionList); - - when(restClient.getBlueprint(Mockito.any(), Mockito.any())).thenReturn(cldBpList) - .thenThrow(Exception.class).thenThrow(httpException); - - String actualResult = subject.getTenantStatusForService(mockedRequest, deplIds); - assertTrue(actualResult.contains("successful")); - - actualResult = subject.getTenantStatusForService(mockedRequest, deplIds); - assertTrue(actualResult.contains("error")); - - actualResult = subject.getTenantStatusForService(mockedRequest, deplIds); - assertTrue(actualResult.contains("error")); - } - - @SuppressWarnings("unchecked") + @Test public void testGetExecutionsByPage() throws Exception { CloudifyExecution cldExecution = - new CloudifyExecution("successful", "created_at", "install", false, "bp1", "id1", - "tenant1", "error", "execution_id1", null, false, false); - + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); + List cldExecutionList = new ArrayList(); cldExecutionList.add(cldExecution); @@ -301,8 +644,8 @@ public class CloudifyControllerTest extends MockitoTestSuite { CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); CloudifyDeploymentList cldDeployList = new CloudifyDeploymentList(cfyDeployItems, metadata); - - when(restClient.getDeployments()).thenReturn(cldDeployList); + + when(restClient.getDeployments(Mockito.any(), Mockito.anyInt(), Mockito.anyInt())).thenReturn(cldDeployList); when(restClient.getExecutions(Mockito.any(), Mockito.any())) .thenReturn(cloudifyExecutionList).thenThrow(Exception.class) .thenReturn(cloudifyExecutionList); @@ -317,13 +660,13 @@ public class CloudifyControllerTest extends MockitoTestSuite { actualResult = subject.getExecutionsByPage(mockedRequest, null, "successful", "tenant1"); assertTrue(actualResult.contains("successful")); } - +/* @SuppressWarnings("unchecked") @Test public void testGetExecutionByIdAndDeploymentId() throws Exception { CloudifyExecution cldExecution = - new CloudifyExecution("successful", "created_at", "install", false, "bp1", "id1", - "tenant1", "error", "execution_id1", null, false, false); + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); List cldExecutionList = new ArrayList(); @@ -347,7 +690,7 @@ public class CloudifyControllerTest extends MockitoTestSuite { "tenant", mockedRequest); assertTrue(actualResult.contains("error")); } - +*/ @SuppressWarnings("unchecked") @Test public void testGetExecutionEventsById() throws Exception { @@ -384,8 +727,9 @@ public class CloudifyControllerTest extends MockitoTestSuite { @SuppressWarnings("unchecked") @Test public void testStartExecution() throws Exception { - CloudifyExecution cfyExecObj = new CloudifyExecution("successful", "created_at", "install", - false, "bp1", "id1", "tenant1", "error", "execution_id1", null, false, false); + CloudifyExecution cldExecution = + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); Map params = new HashMap(); params.put("key1", "value1"); @@ -401,12 +745,22 @@ public class CloudifyControllerTest extends MockitoTestSuite { CloudifyNodeInstanceIdList cfyNodeInstList = new CloudifyNodeInstanceIdList(cfyNodeInstItems, null); - + + String secretTokenStr = + "{\"created_at\": \"created_ts\", \"key\": \"acl_key\", \"updated_at\": \"updated_ts\", \"value\": \"acl_token_val\", \"visibility\": \"global\", \"is_hidden_value\": \"false\", \"tenant_name\": \"tenant\", \"resource_availability\": \"rsrc\"}"; + CloudifySecret secretData = null; + try { + secretData = objectMapper.readValue(secretTokenStr, CloudifySecret.class); + } catch (Exception e) { + + } + when(restClient.getSecret(Mockito.any(), Mockito.any())).thenReturn(secretData); + when(restClient.getNodeInstanceId(Mockito.any(), Mockito.any())) .thenReturn(cfyNodeInstList); when(restClient.startExecution(Matchers.any())) - .thenReturn(cfyExecObj).thenThrow(Exception.class).thenThrow(httpException); + .thenReturn(cldExecution).thenThrow(Exception.class).thenThrow(httpException); String actualResult = subject.startExecution(mockedRequest, cfyExecReq); assertTrue(actualResult.contains("execution_id1")); @@ -418,32 +772,6 @@ public class CloudifyControllerTest extends MockitoTestSuite { assertTrue(actualResult.contains("error")); } - @SuppressWarnings("unchecked") - @Test - public void testUpdateDeployment() throws Exception { - - CloudifyDeploymentUpdateRequest cfyDeployUpdateReq = - new CloudifyDeploymentUpdateRequest("deployment_id", "update", false, false, - "node_instance_id1", "4", "1000", "image", 2, "my_container"); - - CloudifyDeploymentUpdateResponse cfyDeployUpdateResp = new CloudifyDeploymentUpdateResponse( - "terminated", "created_at", "update", false, "blueprint_id", "deployment_id", "", "id1", - null, "tenant1", "junit", false, "resource_availability"); - - when(restClient.updateDeployment(Matchers.any())) - .thenReturn(cfyDeployUpdateResp).thenThrow(Exception.class).thenThrow(httpException); - - String actualResult = subject.updateDeployment(mockedRequest, cfyDeployUpdateReq); - assertTrue(actualResult.contains("terminated")); - - actualResult = subject.updateDeployment(mockedRequest, cfyDeployUpdateReq); - assertTrue(actualResult.contains("error")); - - actualResult = subject.updateDeployment(mockedRequest, cfyDeployUpdateReq); - assertTrue(actualResult.contains("error")); - - } - @SuppressWarnings("unchecked") @Test public void testGetNodeInstanceId() throws Exception { @@ -506,8 +834,9 @@ public class CloudifyControllerTest extends MockitoTestSuite { HttpHeaders httpHeader = new HttpHeaders(); httpHeader.put("tenant", tenants); - CloudifyExecution cfyExecObj = new CloudifyExecution("successful", "created_at", "cancel", - false, "bp1", "id1", "tenant1", "error", "execution_id1", null, false, false); + CloudifyExecution cfyExecObj = + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); when(restClient.cancelExecution(Mockito.any(), Mockito.any(), Mockito.any())) .thenReturn(cfyExecObj).thenThrow(Exception.class).thenThrow(httpException); diff --git a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/CommonApiControllerTest.java b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/CommonApiControllerTest.java deleted file mode 100644 index 7097275..0000000 --- a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/CommonApiControllerTest.java +++ /dev/null @@ -1,791 +0,0 @@ -/******************************************************************************* - * =============LICENSE_START========================================================= - * - * ================================================================================= - * Copyright (c) 2019 AT&T Intellectual Property. All rights reserved. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - * - * ECOMP is a trademark and service mark of AT&T Intellectual Property. - *******************************************************************************/ - -package org.onap.ccsdk.dashboard.controller; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.doNothing; -import static org.mockito.Mockito.when; - -import java.io.ByteArrayInputStream; -import java.io.IOException; -import java.io.InputStream; -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.stream.Stream; - -import javax.servlet.http.HttpServletRequest; -import javax.servlet.http.HttpServletResponse; - -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.mockito.InjectMocks; -import org.mockito.Matchers; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; -import org.onap.ccsdk.dashboard.core.MockUser; -import org.onap.ccsdk.dashboard.core.MockitoTestSuite; -import org.onap.ccsdk.dashboard.domain.EcdComponent; -import org.onap.ccsdk.dashboard.exceptions.BadRequestException; -import org.onap.ccsdk.dashboard.exceptions.DeploymentNotFoundException; -import org.onap.ccsdk.dashboard.exceptions.DownstreamException; -import org.onap.ccsdk.dashboard.exceptions.ServerErrorException; -import org.onap.ccsdk.dashboard.exceptions.ServiceAlreadyExistsException; -import org.onap.ccsdk.dashboard.exceptions.inventory.BlueprintParseException; -import org.onap.ccsdk.dashboard.exceptions.inventory.ServiceTypeNotFoundException; -import org.onap.ccsdk.dashboard.model.CloudifyDeployedTenant; -import org.onap.ccsdk.dashboard.model.CloudifyDeployedTenantList; -import org.onap.ccsdk.dashboard.model.CloudifyDeployment; -import org.onap.ccsdk.dashboard.model.CloudifyDeploymentList; -import org.onap.ccsdk.dashboard.model.CloudifyExecution; -import org.onap.ccsdk.dashboard.model.CloudifyExecutionList; -import org.onap.ccsdk.dashboard.model.CloudifyExecutionRequest; -import org.onap.ccsdk.dashboard.model.CloudifyNodeInstance; -import org.onap.ccsdk.dashboard.model.CloudifyNodeInstanceId; -import org.onap.ccsdk.dashboard.model.CloudifyNodeInstanceIdList; -import org.onap.ccsdk.dashboard.model.CloudifyNodeInstanceList; -import org.onap.ccsdk.dashboard.model.CloudifyTenant; -import org.onap.ccsdk.dashboard.model.CloudifyTenantList; -import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentInput; -import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentRequest; -import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentResponse; -import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentResponseLinks; -import org.onap.ccsdk.dashboard.model.inventory.Service; -import org.onap.ccsdk.dashboard.model.inventory.ServiceList; -import org.onap.ccsdk.dashboard.model.inventory.ServiceQueryParams; -import org.onap.ccsdk.dashboard.model.inventory.ServiceRef; -import org.onap.ccsdk.dashboard.model.inventory.ServiceRefList; -import org.onap.ccsdk.dashboard.model.inventory.ServiceType; -import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeList; -import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeQueryParams; -import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeRequest; -import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeUploadRequest; -import org.onap.ccsdk.dashboard.rest.CloudifyClient; -import org.onap.ccsdk.dashboard.rest.DeploymentHandlerClient; -import org.onap.ccsdk.dashboard.rest.InventoryClient; -import org.onap.ccsdk.dashboard.service.ControllerEndpointService; -import org.springframework.http.HttpHeaders; -import org.springframework.http.HttpStatus; -import org.springframework.web.client.HttpServerErrorException; -import org.springframework.web.client.HttpStatusCodeException; - -import com.fasterxml.jackson.core.JsonParseException; -import com.fasterxml.jackson.core.JsonProcessingException; -import com.fasterxml.jackson.databind.JsonMappingException; -import com.fasterxml.jackson.databind.ObjectMapper; -import com.fasterxml.jackson.datatype.jdk8.Jdk8Module; - -public class CommonApiControllerTest extends MockitoTestSuite { - - @Mock - private CloudifyClient cfyClient; - - @Mock - private InventoryClient inventoryClient; - - @Mock - DeploymentHandlerClient deploymentHandlerClient; - - @Mock - ControllerEndpointService controllerEndpointService; - - @InjectMocks - CommonApiController subject = new CommonApiController(); - - private HttpStatusCodeException httpException = - new HttpServerErrorException(HttpStatus.BAD_GATEWAY); - - protected final ObjectMapper objectMapper = new ObjectMapper(); - - HttpServletRequest mockedRequest; - HttpServletResponse mockedResponse; - - MockUser mockUser = new MockUser(); - ServiceList deplList = null; - Service deplItem = null; - - ServiceType bpItem = null; - ServiceType bpItem2 = null; - ServiceTypeList bpList = null; - ServiceTypeList bpList2 = null; - - ServiceTypeRequest bpUploadItem = null; - - BadRequestException badReqError; - ServiceAlreadyExistsException srvcExistError; - ServerErrorException serverError; - DownstreamException downStrmError; - JsonProcessingException jsonError; - DeploymentNotFoundException notFoundError; - private ServiceTypeNotFoundException serviceTypeException = - new ServiceTypeNotFoundException("Invalid blueprint"); - - @Before - public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - objectMapper.registerModule(new Jdk8Module()); - getExpectedDeployments(); - getExpectedBueprints(); - createBpUploadItem(); - mockedRequest = getMockedRequest(); - mockedResponse = getMockedResponse(); - badReqError = new BadRequestException("bad request"); - srvcExistError = new ServiceAlreadyExistsException("service already exists"); - serverError = new ServerErrorException("Error occured in server"); - downStrmError = new DownstreamException("error occured in downstream"); - notFoundError = new DeploymentNotFoundException("item not found"); - } - - public void getExpectedDeployments() - throws JsonParseException, JsonMappingException, IOException { - - deplItem = new Service("dcae_dtiapi_1902", null, "1552335532348", "1552335532348", null, - "dummyVnfId", null, "dummyVnfType", "dummyLocation", "dcae_dtiapi_1902", null); - Collection items = new ArrayList(); - items.add(deplItem); - - String pageLinks = - "{\"previousLink\":null,\"nextLink\":{\"rel\":\"next\",\"href\":\"https://invt.com:30123/dcae-services/?offset=25\"}}"; - ServiceList.PaginationLinks paginationLinks = - objectMapper.readValue(pageLinks, ServiceList.PaginationLinks.class); - int totalCount = 1; - deplList = new ServiceList(items, totalCount, paginationLinks); - - } - - public void getExpectedBueprints() - throws JsonParseException, JsonMappingException, IOException { - bpItem = new ServiceType.Builder("xyz1731", "xyz1731-helm-1906", 1906, - "tosca_definitions_version: cloudify_dsl_1_3", "", "app1", "comp1").build(); - - Collection items = new ArrayList(); - items.add(bpItem); - - String pageLinks2 = - "{\"previousLink\":null,\"nextLink\":{\"rel\":\"next\",\"href\":\"https://invt.com:30123/dcae-services/?offset=25\"}}"; - ServiceTypeList.PaginationLinks paginationLinks = - objectMapper.readValue(pageLinks2, ServiceTypeList.PaginationLinks.class); - int totalCount = 1; - bpList = new ServiceTypeList(items, totalCount, paginationLinks); - - bpItem2 = new ServiceType("xyz1731", "xyz1731-helm-1907", 1906, - "tosca_definitions_version: cloudify_dsl_1_3\\r\\nimports:\\r\\n - http://www.getcloudify.org/spec/cloudify/4.2/types.yaml\\r\\n", - "app1", "comp1", null, null, null, null, null, null, "typeId", null, "created", null, - true); - - Collection items2 = new ArrayList(); - items2.add(bpItem2); - - bpList2 = new ServiceTypeList(items2, totalCount, paginationLinks); - } - - public void createBpUploadItem() { - bpUploadItem = ServiceTypeRequest.from(bpItem); - } - - @After - public void tearDown() throws Exception { - } - - @Test - public final void testInsertComponent() throws Exception { - EcdComponent component1 = new EcdComponent(); - - component1.setCname("comp1"); - component1.setCompId(100L); - component1.setDname("COMP1"); - - doNothing().when(controllerEndpointService).insertComponent(component1); - - String actualResult = subject.insertComponent(mockedRequest, component1); - assertTrue(actualResult.contains("Inserted")); - } - - @Test - public final void testGetComponents() throws Exception { - EcdComponent component1 = new EcdComponent(); - EcdComponent component2 = new EcdComponent(); - - component1.setCname("comp1"); - component1.setCompId(100L); - component1.setDname("COMP1"); - - component2.setCname("comp2"); - component2.setCompId(200L); - component2.setDname("COMP2"); - - List compsList = new ArrayList(); - compsList.add(component1); - compsList.add(component2); - - when(controllerEndpointService.getComponents()).thenReturn(compsList); - - String actualResult = subject.getComponents(mockedRequest); - assertTrue(actualResult.contains("comp1")); - } - - @Test - public final void testGetTenants() throws Exception { - String tenantsList = - "{\"items\": [{\"id\": 1, \"name\": \"default_tenant\", \"dName\": \"default_tenant\" }, " - + "{\"id\": 2, \"name\": \"dyh1b1902\", \"dName\": \"dyh1b1902\"}], " - + "\"metadata\": {\"pagination\": {\"total\": 2, \"offset\": 0, \"size\": 0}}}"; - CloudifyTenantList sampleData = null; - try { - sampleData = objectMapper.readValue(tenantsList, CloudifyTenantList.class); - } catch (Exception e) { - } - MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); - - Mockito.when(cfyClient.getTenants()).thenReturn(sampleData); - - String tenantStr = subject.getTenants(mockedRequest); - assertTrue(tenantStr.contains("dyh1b")); - } - - @SuppressWarnings("unchecked") - @Test - public final void testGetTenantStatusForService() throws Exception { - String[] deplIds = {"id1", "id2"}; - - CloudifyDeployedTenant cldDeplTenant = new CloudifyDeployedTenant("id1", "bp1", "tenant1"); - - List cldDeplTenantList = new ArrayList(); - - cldDeplTenantList.add(cldDeplTenant); - - CloudifyDeployedTenantList cldDeployedTenantList = - new CloudifyDeployedTenantList(cldDeplTenantList, null); - - CloudifyTenant cldTenant = new CloudifyTenant("tenant1", "tenant1", "tenant_id1"); - - List cldfyTenantList = new ArrayList(); - cldfyTenantList.add(cldTenant); - - CloudifyTenantList cloudifyTenantList = new CloudifyTenantList(cldfyTenantList, null); - - CloudifyExecution cldExecution = - new CloudifyExecution("successful", "created_at", "install", false, "bp1", "id1", - "tenant1", "error", "execution_id1", null, false, false); - - List cldExecutionList = new ArrayList(); - - cldExecutionList.add(cldExecution); - - CloudifyExecutionList cloudifyExecutionList = - new CloudifyExecutionList(cldExecutionList, null); - - when(cfyClient.getTenants()).thenReturn(cloudifyTenantList); - - when(cfyClient.getTenantInfoFromDeploy(Mockito.any())).thenReturn(cldDeployedTenantList); - - when(cfyClient.getExecutionsSummary(Mockito.any(), Mockito.any())) - .thenReturn(cloudifyExecutionList).thenThrow(Exception.class).thenThrow(httpException); - - String actualResult = subject.getTenantStatusForService(mockedRequest, deplIds); - assertTrue(actualResult.contains("successful")); - - actualResult = subject.getTenantStatusForService(mockedRequest, deplIds); - assertTrue(actualResult.contains("error")); - - actualResult = subject.getTenantStatusForService(mockedRequest, deplIds); - assertTrue(actualResult.contains("error")); - } - - @SuppressWarnings("unchecked") - @Test - public final void testCreateBlueprint() throws Exception { - ServiceTypeUploadRequest bpUploadReq = ServiceTypeUploadRequest.from(bpItem); - - when(inventoryClient.addServiceType(Matchers.any())) - .thenThrow(BlueprintParseException.class).thenThrow(httpException) - .thenThrow(Exception.class).thenReturn(bpItem); - - String actual1 = subject.createBlueprint(mockedRequest, bpUploadReq); - assertTrue(actual1.contains("error")); - - String actual2 = subject.createBlueprint(mockedRequest, bpUploadReq); - assertTrue(actual2.contains("error")); - - String actual3 = subject.createBlueprint(mockedRequest, bpUploadReq); - assertTrue(actual3.contains("error")); - - String actual = subject.createBlueprint(mockedRequest, bpUploadReq); - assertTrue(actual.contains("app1")); - - } - - @SuppressWarnings("unchecked") - @Test - public final void testGetBlueprintsByPage() { - MockHttpServletRequestWrapper mockedRequest1 = getMockedRequest(); - mockedRequest1.addParameter("_include", "typeName,typeId,typeVersion"); - mockedRequest1.addParameter("name", "xyz"); - - Collection items = bpList.items; - Stream sampleStream1 = items.stream(); - Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) - .thenReturn(sampleStream1).thenThrow(Exception.class).thenThrow(httpException); - - String result = subject.getBlueprintsByPage(mockedRequest1); - assertTrue(result.contains("xyz")); - - result = subject.getBlueprintsByPage(mockedRequest1); - assertTrue(result.contains("error")); - - result = subject.getBlueprintsByPage(mockedRequest1); - assertTrue(result.contains("error")); - - } - - @SuppressWarnings("unchecked") - @Test - public final void testQueryBlueprintFilter() { - MockHttpServletRequestWrapper mockedRequest1 = getMockedRequest(); - mockedRequest1.addParameter("_include", "typeName,typeId,typeVersion"); - mockedRequest1.addParameter("name", "xyz"); - - Collection items = bpList.items; - Stream sampleStream1 = items.stream(); - Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) - .thenReturn(sampleStream1).thenThrow(Exception.class).thenThrow(httpException); - - String result = subject.queryBlueprintFilter(mockedRequest1); - assertTrue(result.contains("xyz")); - - result = subject.queryBlueprintFilter(mockedRequest1); - assertTrue(result.contains("error")); - - result = subject.queryBlueprintFilter(mockedRequest1); - assertTrue(result.contains("error")); - } - - @SuppressWarnings("unchecked") - @Test - public final void testGetDeploymentsByPage() { - CloudifyDeployedTenant cldDeplTenant = - new CloudifyDeployedTenant("dcae_dtiapi_1902", "dcae_dtiapi_1902", "tenant1"); - - List cldDeplTenantList = new ArrayList(); - - cldDeplTenantList.add(cldDeplTenant); - - CloudifyDeployedTenantList cldDeployedTenantList = - new CloudifyDeployedTenantList(cldDeplTenantList, null); - - CloudifyTenant cldTenant = new CloudifyTenant("tenant1", "tenant1", "tenant_id1"); - - List cldfyTenantList = new ArrayList(); - cldfyTenantList.add(cldTenant); - - CloudifyTenantList cloudifyTenantList = new CloudifyTenantList(cldfyTenantList, null); - - MockHttpServletRequestWrapper mockedRequest1 = getMockedRequest(); - mockedRequest1.addParameter("_include", "id"); - mockedRequest1.addParameter("searchBy", "dti"); - - Collection items = deplList.items; - - when(cfyClient.getTenants()).thenReturn(cloudifyTenantList); - - when(cfyClient.getTenantInfoFromDeploy(Mockito.any())).thenReturn(cldDeployedTenantList) - .thenThrow(Exception.class).thenThrow(httpException).thenReturn(cldDeployedTenantList) - .thenReturn(cldDeployedTenantList); - - Stream sampleStream1 = items.stream(); - Stream sampleStream2 = items.stream(); - Stream sampleStream3 = items.stream(); - - Mockito.when(inventoryClient.getServices()).thenReturn(sampleStream1) - .thenReturn(sampleStream2).thenReturn(sampleStream3).thenThrow(Exception.class) - .thenThrow(httpException); - - String result = subject.getDeploymentsByPage("dcae_dtiapi_1902", mockedRequest1); - assertTrue(result.contains("dti")); - - result = subject.getDeploymentsByPage("dcae_dtiapi_1902", mockedRequest1); - assertTrue(result.contains("dti")); - - result = subject.getDeploymentsByPage("dcae_dtiapi_1902", mockedRequest1); - assertTrue(result.contains("dti")); - - result = subject.getDeploymentsByPage("dcae_dtiapi_1902", mockedRequest1); - assertTrue(result.contains("error")); - - result = subject.getDeploymentsByPage("dcae_dtiapi_1902", mockedRequest1); - assertTrue(result.contains("error")); - - } - - @SuppressWarnings("unchecked") - @Test - public final void testGetAllDeploymentsByPage() { - CloudifyDeployedTenant cldDeplTenant = - new CloudifyDeployedTenant("dcae_dtiapi_1902", "dcae_dtiapi_1902", "tenant1"); - - List cldDeplTenantList = new ArrayList(); - - cldDeplTenantList.add(cldDeplTenant); - - CloudifyDeployedTenantList cldDeployedTenantList = - new CloudifyDeployedTenantList(cldDeplTenantList, null); - - CloudifyTenant cldTenant = new CloudifyTenant("tenant1", "tenant1", "tenant_id1"); - - List cldfyTenantList = new ArrayList(); - cldfyTenantList.add(cldTenant); - - CloudifyTenantList cloudifyTenantList = new CloudifyTenantList(cldfyTenantList, null); - - MockHttpServletRequestWrapper mockedRequest1 = getMockedRequest(); - mockedRequest1.addParameter("_include", "id"); - mockedRequest1.addParameter("searchBy", "dti"); - - Collection items = deplList.items; - - when(cfyClient.getTenants()).thenReturn(cloudifyTenantList); - - when(cfyClient.getTenantInfoFromDeploy(Mockito.any())).thenReturn(cldDeployedTenantList) - .thenThrow(Exception.class).thenThrow(httpException).thenReturn(cldDeployedTenantList) - .thenReturn(cldDeployedTenantList); - - Stream sampleStream1 = items.stream(); - Stream sampleStream2 = items.stream(); - Stream sampleStream3 = items.stream(); - - Mockito.when(inventoryClient.getServices()).thenReturn(sampleStream1) - .thenReturn(sampleStream2).thenReturn(sampleStream3).thenThrow(Exception.class) - .thenThrow(httpException); - - String result = subject.getAllDeploymentsByPage(mockedRequest1); - assertTrue(result.contains("dti")); - - result = subject.getAllDeploymentsByPage(mockedRequest1); - assertTrue(result.contains("dti")); - - result = subject.getAllDeploymentsByPage(mockedRequest1); - assertTrue(result.contains("dti")); - - result = subject.getAllDeploymentsByPage(mockedRequest1); - assertTrue(result.contains("error")); - - result = subject.getAllDeploymentsByPage(mockedRequest1); - assertTrue(result.contains("error")); - } - - @SuppressWarnings("unchecked") - @Test - public final void testGetDeploymentRevisions() throws Exception { - CloudifyNodeInstance cfyNodeInstance = new CloudifyNodeInstance("id1", null); - - List cfyNodeInstanceItems = new ArrayList(); - cfyNodeInstanceItems.add(cfyNodeInstance); - - CloudifyNodeInstanceList cfyNodeInstList = - new CloudifyNodeInstanceList(cfyNodeInstanceItems, null); - - when(cfyClient.getNodeInstanceVersion(Mockito.any(), Mockito.any())) - .thenReturn(cfyNodeInstList).thenThrow(Exception.class).thenThrow(httpException); - - String actualResult = - subject.getDeploymentRevisions("deploymentId", "tenant", mockedRequest); - assertTrue(actualResult.contains("id1")); - - actualResult = subject.getDeploymentRevisions("deploymentId", "tenant", mockedRequest); - assertTrue(actualResult.contains("error")); - - actualResult = subject.getDeploymentRevisions("deploymentId", "tenant", mockedRequest); - assertTrue(actualResult.contains("error")); - } - - @Test - public final void testGetDeploymentInputs() throws Exception { - - Map inputHash = new HashMap(); - inputHash.put("key1", "value1"); - - CloudifyDeployment cldDeployment = - new CloudifyDeployment("description", "blueprint_id", "created_at", "updated_at", "id", - inputHash, null, null, null, null, null, null, "tenant"); - - List cfyDeployItems = new ArrayList(); - cfyDeployItems.add(cldDeployment); - - CloudifyDeploymentList.Metadata.Pagination pageObj = - new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); - CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); - - CloudifyDeploymentList cldDeployList = new CloudifyDeploymentList(cfyDeployItems, metadata); - - when(cfyClient.getDeploymentInputs(Matchers.any(), Matchers.any())) - .thenReturn(cldDeployList); - - String actualResult = subject.getDeploymentInputs("deploymentId", "tenant", mockedRequest); - assertTrue(actualResult.contains("blueprint_id")); - } - - @SuppressWarnings("unchecked") - @Test - public final void testModifyDeployment() throws Exception { - CloudifyExecution cfyExecObj = new CloudifyExecution("successful", "created_at", "install", - false, "bp1", "id1", "tenant1", "error", "execution_id1", null, false, false); - - Map params = new HashMap(); - params.put("tenant", "tenant1"); - params.put("workflow", "upgrade"); - - CloudifyExecutionRequest cfyExecReq = new CloudifyExecutionRequest("deployment_id", - "upgrade", false, false, "tenant1", params); - - CloudifyNodeInstanceId cfyNodeInst = new CloudifyNodeInstanceId("node_instance_id1"); - - List cfyNodeInstItems = new ArrayList(); - - cfyNodeInstItems.add(cfyNodeInst); - - CloudifyNodeInstanceIdList cfyNodeInstList = - new CloudifyNodeInstanceIdList(cfyNodeInstItems, null); - - when(cfyClient.getNodeInstanceId(Mockito.any(), Mockito.any())).thenReturn(cfyNodeInstList); - - when(cfyClient.startExecution(Matchers.any())) - .thenReturn(cfyExecObj).thenThrow(Exception.class).thenThrow(httpException); - - String inputParamStr = "{\"tenant\": \"tenant1\", \"workflow\":\"upgrade\"}"; - - InputStream is = new ByteArrayInputStream(inputParamStr.getBytes()); - - String actualResult = subject.modifyDeployment("depId", mockedRequest, is); - assertTrue(actualResult.contains("execution_id1")); - - actualResult = subject.modifyDeployment("depId", mockedRequest, is); - assertTrue(actualResult.contains("error")); - - actualResult = subject.modifyDeployment("depId", mockedRequest, is); - assertTrue(actualResult.contains("error")); - - } - - @Test - public final void testGetServicesForType() throws Exception { - ServiceRef expectedSrvc = new ServiceRef("dcae_dtiapi_1902", "432423", "433434"); - Collection expectedSrvcIds = new ArrayList(); - expectedSrvcIds.add(expectedSrvc); - ServiceRefList expectedSrvcRefList = new ServiceRefList(expectedSrvcIds, 1); - - when(inventoryClient.getServicesForType(Matchers.any())) - .thenReturn(expectedSrvcRefList); - String actual = subject.getServicesForType(mockedRequest, "typeId1"); - assertTrue(actual.contains("typeId1")); - } - - @SuppressWarnings("unchecked") - @Test - public final void testCreateDeployment() throws Exception { - DeploymentInput deployInput1 = new DeploymentInput("component1", "tag1", - "xyz1731-helm-1906", 1906, "blueprintId", null, "tenant1"); - - DeploymentInput deployInput2 = new DeploymentInput("component1", "tag1", - "xyz1731-helm-1906", 1906, null, null, "tenant1"); - - DeploymentResponseLinks expectLink = new DeploymentResponseLinks("self", "status"); - DeploymentResponse expectResp = new DeploymentResponse("req1", expectLink); - - Collection items = bpList2.items; - Stream sampleStream1 = items.stream(); - Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) - .thenReturn(sampleStream1); - - String actualResp0 = subject.createDeployment(mockedRequest, deployInput2); - assertTrue(actualResp0.contains("error")); - - StringBuffer expectedStrBuff = new StringBuffer(); - expectedStrBuff.append("http://oom.s2.com"); - when(mockedRequest.getRequestURL()).thenReturn(expectedStrBuff); - - when(deploymentHandlerClient.putDeployment(Matchers.anyString(), Matchers.anyString(), - Matchers.any())).thenReturn(expectResp).thenThrow(badReqError) - .thenThrow(srvcExistError).thenThrow(serverError).thenThrow(downStrmError) - .thenThrow(Exception.class); - - String actualResp = subject.createDeployment(mockedRequest, deployInput1); - assertTrue(actualResp.contains("component1")); - - actualResp = subject.createDeployment(mockedRequest, deployInput1); - assertTrue(actualResp.contains("error")); - - actualResp = subject.createDeployment(mockedRequest, deployInput1); - assertTrue(actualResp.contains("error")); - - actualResp = subject.createDeployment(mockedRequest, deployInput1); - assertTrue(actualResp.contains("error")); - - actualResp = subject.createDeployment(mockedRequest, deployInput1); - assertTrue(actualResp.contains("error")); - - actualResp = subject.createDeployment(mockedRequest, deployInput1); - assertTrue(actualResp.contains("error")); - - } - - @SuppressWarnings("unchecked") - @Test - public final void testUpdateDeployment() throws Exception { - - DeploymentInput deployInput1 = new DeploymentInput("component1", "tag1", - "xyz1731-helm-1906", 1906, "blueprintId", null, "tenant1"); - - DeploymentResponseLinks expectLink = new DeploymentResponseLinks("self", "status"); - DeploymentResponse expectResp = new DeploymentResponse("req1", expectLink); - - Collection items = bpList2.items; - Stream sampleStream1 = items.stream(); - Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) - .thenReturn(sampleStream1); - - when(deploymentHandlerClient.updateDeployment(Matchers.anyString(), Matchers.anyString(), - Matchers.any())).thenReturn(expectResp).thenThrow(badReqError) - .thenThrow(srvcExistError).thenThrow(serverError).thenThrow(downStrmError) - .thenThrow(Exception.class); - - String actualResp = subject.updateDeployment("id1", mockedRequest, deployInput1); - assertTrue(actualResp.contains("req1")); - - actualResp = subject.updateDeployment("id1", mockedRequest, deployInput1); - assertTrue(actualResp.contains("error")); - - actualResp = subject.updateDeployment("id1", mockedRequest, deployInput1); - assertTrue(actualResp.contains("error")); - - actualResp = subject.updateDeployment("id1", mockedRequest, deployInput1); - assertTrue(actualResp.contains("error")); - - actualResp = subject.updateDeployment("id1", mockedRequest, deployInput1); - assertTrue(actualResp.contains("error")); - - actualResp = subject.updateDeployment("id1", mockedRequest, deployInput1); - assertTrue(actualResp.contains("error")); - } - - @Test - public final void testGetExecutionByDeploymentId() throws Exception { - - CloudifyExecution cldExecution = - new CloudifyExecution("successful", "created_at", "install", false, "bp1", "id1", - "tenant1", "error", "execution_id1", null, false, false); - - List cldExecutionList = new ArrayList(); - - cldExecutionList.add(cldExecution); - - CloudifyExecutionList cloudifyExecutionList = - new CloudifyExecutionList(cldExecutionList, null); - - when(cfyClient.getExecutionsSummary(Mockito.any(), Mockito.any())) - .thenReturn(cloudifyExecutionList); - - String actualResult = - subject.getExecutionByDeploymentId("dep_id", "tenant1", mockedRequest); - assertTrue(actualResult.contains("execution_id1")); - } - - @Test - public final void testDeleteBlueprint() throws Exception { - String expected = "{\"202\": \"OK\"}"; - doNothing().doThrow(serviceTypeException).doThrow(Exception.class).when(inventoryClient) - .deleteServiceType(Matchers.anyString()); - - String actual = subject.deleteBlueprint("srvcId", mockedRequest, mockedResponse); - assertEquals(expected, actual); - - actual = subject.deleteBlueprint("srvcId", mockedRequest, mockedResponse); - assertTrue(actual.contains("error")); - - actual = subject.deleteBlueprint("srvcId", mockedRequest, mockedResponse); - assertTrue(actual.contains("error")); - } - - @Test - public final void testDeleteDeployment() throws Exception { - doNothing().doThrow(badReqError).doThrow(serverError).doThrow(downStrmError) - .doThrow(notFoundError).doThrow(Exception.class).when(deploymentHandlerClient) - .deleteDeployment(Matchers.anyString(), Matchers.anyString()); - - StringBuffer expectedStrBuff = new StringBuffer(); - expectedStrBuff.append("http://oom.s2.com"); - when(mockedRequest.getRequestURL()).thenReturn(expectedStrBuff); - - String actual = subject.deleteDeployment("dep1", mockedRequest, "tenant1", mockedResponse); - assertFalse(actual.contains("error")); - - actual = subject.deleteDeployment("dep1", mockedRequest, "tenant1", mockedResponse); - assertTrue(actual.contains("error")); - - actual = subject.deleteDeployment("dep1", mockedRequest, "tenant1", mockedResponse); - assertTrue(actual.contains("error")); - - actual = subject.deleteDeployment("dep1", mockedRequest, "tenant1", mockedResponse); - assertTrue(actual.contains("error")); - - actual = subject.deleteDeployment("dep1", mockedRequest, "tenant1", mockedResponse); - assertTrue(actual.contains("error")); - - actual = subject.deleteDeployment("dep1", mockedRequest, "tenant1", mockedResponse); - assertTrue(actual.contains("error")); - } - - @SuppressWarnings("unchecked") - @Test - public final void testCancelExecution() throws Exception { - List tenants = new ArrayList(); - tenants.add("tenant1"); - - HttpHeaders httpHeader = new HttpHeaders(); - httpHeader.put("tenant", tenants); - - CloudifyExecution cfyExecObj = new CloudifyExecution("successful", "created_at", "cancel", - false, "bp1", "id1", "tenant1", "error", "execution_id1", null, false, false); - - when(cfyClient.cancelExecution(Mockito.any(), Mockito.any(), Mockito.any())) - .thenReturn(cfyExecObj).thenThrow(Exception.class).thenThrow(httpException); - - String actualResult = - subject.cancelExecution(httpHeader, "id1", null, mockedRequest, mockedResponse); - assertTrue(actualResult.contains("execution_id1")); - - actualResult = - subject.cancelExecution(httpHeader, "id1", null, mockedRequest, mockedResponse); - assertTrue(actualResult.contains("error")); - - actualResult = - subject.cancelExecution(httpHeader, "id1", null, mockedRequest, mockedResponse); - assertTrue(actualResult.contains("error")); - } - -} diff --git a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/ConsulControllerTest.java b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/ConsulControllerTest.java index 3d71a2e..53657ed 100644 --- a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/ConsulControllerTest.java +++ b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/ConsulControllerTest.java @@ -28,6 +28,8 @@ import static org.mockito.Mockito.when; import java.util.ArrayList; import java.util.List; +import javax.servlet.http.HttpServletRequest; + import org.junit.After; import org.junit.Before; import org.junit.Ignore; @@ -37,14 +39,15 @@ import org.mockito.Matchers; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import org.onap.ccsdk.dashboard.controller.ConsulController.ConsulDataItem; import org.onap.ccsdk.dashboard.core.MockUser; import org.onap.ccsdk.dashboard.core.MockitoTestSuite; -import org.onap.ccsdk.dashboard.model.ConsulDatacenter; -import org.onap.ccsdk.dashboard.model.ConsulHealthServiceRegistration; -import org.onap.ccsdk.dashboard.model.ConsulNodeInfo; -import org.onap.ccsdk.dashboard.model.ConsulServiceHealth; -import org.onap.ccsdk.dashboard.model.ConsulServiceInfo; import org.onap.ccsdk.dashboard.model.RestResponseSuccess; +import org.onap.ccsdk.dashboard.model.consul.ConsulDatacenter; +import org.onap.ccsdk.dashboard.model.consul.ConsulHealthServiceRegistration; +import org.onap.ccsdk.dashboard.model.consul.ConsulNodeInfo; +import org.onap.ccsdk.dashboard.model.consul.ConsulServiceHealth; +import org.onap.ccsdk.dashboard.model.consul.ConsulServiceInfo; import org.onap.ccsdk.dashboard.rest.ConsulClient; import org.onap.portalsdk.core.domain.User; import org.onap.portalsdk.core.web.support.UserUtils; @@ -67,6 +70,8 @@ public class ConsulControllerTest extends MockitoTestSuite { MockUser mockUser = new MockUser(); HttpClientErrorException httpException; + String[] svcTags = {"cfytenantname=onap"}; + @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); @@ -87,7 +92,7 @@ public class ConsulControllerTest extends MockitoTestSuite { "service:pgaas1_Service_ID", "Service 'pgaasServer1' check", "passing", "This is a pgaas1_Service_ID health check", "HTTP GET http://srvc.com:8000/healthcheck/status: 200 OK Output: { \"output\": \"Thu Apr 20 19:53:01 UTC 2017|INFO|masters=1 pgaas1.com|secondaries=0 |maintenance= |down=1 pgaas2.com| \" }\n", - "pgaas1_Service_ID", "pgaasServer1", 190199, 199395); + "pgaas1_Service_ID", "pgaasServer1", svcTags, 190199, 199395); List expectedCnslSrvcHlth = new ArrayList(); expectedCnslSrvcHlth.add(consulSrvcHlth); @@ -118,7 +123,7 @@ public class ConsulControllerTest extends MockitoTestSuite { "service:pgaas1_Service_ID", "Service 'pgaasServer1' check", "passing", "This is a pgaas1_Service_ID health check", "HTTP GET http://srvc.com:8000/healthcheck/status: 200 OK Output: { \"output\": \"Thu Apr 20 19:53:01 UTC 2017|INFO|masters=1 pgaas1.com|secondaries=0 |maintenance= |down=1 pgaas2.com| \" }\n", - "pgaas1_Service_ID", "pgaasServer1", 190199, 199395); + "pgaas1_Service_ID", "pgaasServer1", svcTags, 190199, 199395); List expectedCnslSrvcHlth = new ArrayList(); expectedCnslSrvcHlth.add(consulSrvcHlth); @@ -160,7 +165,7 @@ public class ConsulControllerTest extends MockitoTestSuite { "service:pgaas1_Service_ID", "Service 'pgaasServer1' check", "passing", "This is a pgaas1_Service_ID health check", "HTTP GET http://srvc.com:8000/healthcheck/status: 200 OK Output: { \"output\": \"Thu Apr 20 19:53:01 UTC 2017|INFO|masters=1 pgaas1.com|secondaries=0 |maintenance= |down=1 pgaas2.com| \" }\n", - "pgaas1_Service_ID", "pgaasServer1", 190199, 199395); + "pgaas1_Service_ID", "pgaasServer1", svcTags, 190199, 199395); List expectedCnslSrvcHlth = new ArrayList(); expectedCnslSrvcHlth.add(consulSrvcHlth); @@ -193,123 +198,15 @@ public class ConsulControllerTest extends MockitoTestSuite { assertTrue(actualResult.contains("dc1")); } - @SuppressWarnings("unchecked") - @Test - public final void testRegisterService() throws Exception { - ConsulHealthServiceRegistration.EndpointCheck endPoint = - new ConsulHealthServiceRegistration.EndpointCheck("endpoint1", "interval1", - "description1", "name1"); - List endPointList = - new ArrayList(); - endPointList.add(endPoint); - - List tagList = new ArrayList(); - tagList.add("tag1"); - tagList.add("tag2"); - - ConsulHealthServiceRegistration.ConsulServiceRegistration servcReg = - new ConsulHealthServiceRegistration.ConsulServiceRegistration("id1", "name1", - "address1", "port1", tagList, endPointList); - List servcRegList = - new ArrayList(); - servcRegList.add(servcReg); - - ConsulHealthServiceRegistration chsrObj = new ConsulHealthServiceRegistration(servcRegList); - - RestResponseSuccess expectedResp = new RestResponseSuccess("Registration yielded code 0"); - String expectedResult = objectMapper.writeValueAsString(expectedResp); - - String expectedStr = "Registration yielded code 0"; - when(consulClient.registerService(Matchers.any())) - .thenReturn(expectedStr).thenThrow(Exception.class).thenThrow(httpException); - - String actualResult = subject.registerService(mockedRequest, chsrObj); - assertTrue(actualResult.equals(expectedResult)); - - actualResult = subject.registerService(mockedRequest, chsrObj); - assertTrue(actualResult.contains("error")); - - actualResult = subject.registerService(mockedRequest, chsrObj); - assertTrue(actualResult.contains("error")); - } - - @Test - public final void testRegisterService_SrvcError() throws Exception { - ConsulHealthServiceRegistration chsrObj = new ConsulHealthServiceRegistration(null); - - String actualResult = subject.registerService(mockedRequest, chsrObj); - assertTrue(actualResult.contains("error")); - } - - @Test - @Ignore - public final void testRegisterService_invalidSrvcError() throws Exception { - ConsulHealthServiceRegistration.EndpointCheck endPoint = - new ConsulHealthServiceRegistration.EndpointCheck("endpoint1", "interval1", - "description1", "name1"); - List endPointList = - new ArrayList(); - endPointList.add(endPoint); - - List tagList = new ArrayList(); - tagList.add("tag1"); - tagList.add("tag2"); - - ConsulHealthServiceRegistration.ConsulServiceRegistration servcReg = - new ConsulHealthServiceRegistration.ConsulServiceRegistration("id1", "name2", - "address2", "port1", tagList, endPointList); - List servcRegList = - new ArrayList(); - servcRegList.add(servcReg); - - ConsulHealthServiceRegistration chsrObj = new ConsulHealthServiceRegistration(servcRegList); - - String actualResult = subject.registerService(mockedRequest, chsrObj); - assertTrue(actualResult.contains("error")); - } - - @Test - public final void testRegisterService_invalidEndptError() throws Exception { - ConsulHealthServiceRegistration.EndpointCheck endPoint = - new ConsulHealthServiceRegistration.EndpointCheck("", "", "description1", "name1"); - List endPointList = - new ArrayList(); - endPointList.add(endPoint); - - List tagList = new ArrayList(); - tagList.add("tag1"); - tagList.add("tag2"); - - ConsulHealthServiceRegistration.ConsulServiceRegistration servcReg = - new ConsulHealthServiceRegistration.ConsulServiceRegistration("id1", "", "", "port1", - tagList, endPointList); - List servcRegList = - new ArrayList(); - servcRegList.add(servcReg); - - ConsulHealthServiceRegistration chsrObj = new ConsulHealthServiceRegistration(servcRegList); - - String actualResult = subject.registerService(mockedRequest, chsrObj); - assertTrue(actualResult.contains("error")); - } - - @SuppressWarnings("unchecked") @Test - public final void testDeregisterService() throws Exception { - RestResponseSuccess expectedResp = new RestResponseSuccess("Deregistration yielded code 0"); - String expectedResult = objectMapper.writeValueAsString(expectedResp); - - when(consulClient.deregisterService(Mockito.any())).thenReturn(0).thenThrow(Exception.class) - .thenThrow(httpException); - - String actualResult = subject.deregisterService(mockedRequest, "srvc1"); - assertTrue(actualResult.equals(expectedResult)); - - actualResult = subject.deregisterService(mockedRequest, "srvc1"); - assertTrue(actualResult.contains("error")); - - actualResult = subject.deregisterService(mockedRequest, "srvc1"); + public final void testGetItemListForPageWrapper() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + user.setId(1000L); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); + String actualResult = + subject.getItemListForPageWrapper(mockedRequest, "dc1", ConsulController.ConsulDataItem.SERVICE_INFO); assertTrue(actualResult.contains("error")); + } - } diff --git a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/DeploymentHandlerControllerTest.java b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/DeploymentHandlerControllerTest.java index 6517b68..4833c12 100644 --- a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/DeploymentHandlerControllerTest.java +++ b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/DeploymentHandlerControllerTest.java @@ -27,6 +27,8 @@ import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.when; +import javax.servlet.http.HttpServletRequest; + import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -88,46 +90,13 @@ public class DeploymentHandlerControllerTest extends MockitoTestSuite { @Test public final void testPutDeployment_create() throws Exception { DeploymentRequestObject expectReq = - new DeploymentRequestObject("dep1", "dep1", null, "tenant1", "create"); - + new DeploymentRequestObject("dep1", "dep1", "create", null, "tenant1"); + DeploymentResponseLinks expectLink = new DeploymentResponseLinks("self", "status"); DeploymentResponse expectResp = new DeploymentResponse("req1", expectLink); - + when(restClient.putDeployment(Matchers.anyString(), Matchers.anyString(), - Matchers.any())).thenReturn(expectResp).thenThrow(badReqError) - .thenThrow(srvcExistError).thenThrow(serverError).thenThrow(downStrmError) - .thenThrow(Exception.class); - - String actualResp = subject.putDeployment(mockedRequest, expectReq); - assertTrue(actualResp.contains("req1")); - - actualResp = subject.putDeployment(mockedRequest, expectReq); - assertTrue(actualResp.contains("error")); - - actualResp = subject.putDeployment(mockedRequest, expectReq); - assertTrue(actualResp.contains("error")); - - actualResp = subject.putDeployment(mockedRequest, expectReq); - assertTrue(actualResp.contains("error")); - - actualResp = subject.putDeployment(mockedRequest, expectReq); - assertTrue(actualResp.contains("error")); - - actualResp = subject.putDeployment(mockedRequest, expectReq); - assertTrue(actualResp.contains("error")); - } - - @SuppressWarnings("unchecked") - @Test - public final void testPutDeployment_update() throws Exception { - DeploymentRequestObject expectReq = - new DeploymentRequestObject("dep1", "dep1", null, "tenant1", "update"); - - DeploymentResponseLinks expectLink = new DeploymentResponseLinks("self", "status"); - DeploymentResponse expectResp = new DeploymentResponse("req1", expectLink); - - when(restClient.updateDeployment(Matchers.anyString(), Matchers.anyString(), - Matchers.any())).thenReturn(expectResp).thenThrow(badReqError) + Matchers.any(), Matchers.any()) ).thenReturn(expectResp).thenThrow(badReqError) .thenThrow(srvcExistError).thenThrow(serverError).thenThrow(downStrmError) .thenThrow(Exception.class); @@ -155,7 +124,7 @@ public class DeploymentHandlerControllerTest extends MockitoTestSuite { doNothing().doThrow(badReqError).doThrow(serverError).doThrow(downStrmError) .doThrow(notFoundError).doThrow(Exception.class).when(restClient) - .deleteDeployment(Matchers.anyString(), Matchers.anyString()); + .deleteDeployment(Matchers.anyString(), Matchers.anyString(), Matchers.any()); StringBuffer expectedStrBuff = new StringBuffer(); expectedStrBuff.append("http://oom.s2.com"); diff --git a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/InventoryControllerTest.java b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/InventoryControllerTest.java index 01858ed..9cce55e 100644 --- a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/InventoryControllerTest.java +++ b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/controller/InventoryControllerTest.java @@ -31,6 +31,8 @@ import java.io.IOException; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; +import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.Set; import java.util.TreeSet; @@ -54,6 +56,7 @@ import org.onap.ccsdk.dashboard.core.MockitoTestSuite; import org.onap.ccsdk.dashboard.exceptions.inventory.BlueprintParseException; import org.onap.ccsdk.dashboard.exceptions.inventory.ServiceNotFoundException; import org.onap.ccsdk.dashboard.exceptions.inventory.ServiceTypeNotFoundException; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeployedTenant; import org.onap.ccsdk.dashboard.model.inventory.Service; import org.onap.ccsdk.dashboard.model.inventory.ServiceList; import org.onap.ccsdk.dashboard.model.inventory.ServiceQueryParams; @@ -63,10 +66,14 @@ import org.onap.ccsdk.dashboard.model.inventory.ServiceType; import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeList; import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeQueryParams; import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeRequest; +import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeSummary; +import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeSummaryList; import org.onap.ccsdk.dashboard.rest.CloudifyClient; import org.onap.ccsdk.dashboard.rest.InventoryClient; import org.onap.ccsdk.dashboard.util.DashboardProperties; import org.onap.portalsdk.core.domain.User; +import org.onap.portalsdk.core.util.CacheManager; +import org.onap.portalsdk.core.util.SystemProperties; import org.onap.portalsdk.core.web.support.AppUtils; import org.onap.portalsdk.core.web.support.UserUtils; import org.powermock.api.mockito.PowerMockito; @@ -82,11 +89,10 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.datatype.jdk8.Jdk8Module; @RunWith(PowerMockRunner.class) -@PrepareForTest({DashboardProperties.class}) public class InventoryControllerTest extends MockitoTestSuite { @Mock - private CloudifyClient restClient; + private CloudifyClient cfyClient; @Mock private InventoryClient inventoryClient; @@ -118,525 +124,293 @@ public class InventoryControllerTest extends MockitoTestSuite { HttpServletResponse mockedResponse; MockUser mockUser = new MockUser(); - ServiceList deplList = null; - Service deplItem = null; - ServiceType bpItem = null; - ServiceTypeList bpList = null; + ServiceTypeSummary bpItem, bpItem2 = null; + ServiceTypeSummaryList bpList, bpList2 = null; + ServiceType bpItemFull = null; + ServiceTypeList bpItemFullList = null; + ServiceTypeRequest bpUploadItem = null; @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); objectMapper.registerModule(new Jdk8Module()); - getExpectedDeployments(); - getExpectedBueprints(); + getExpectedBlueprints(); createBpUploadItem(); mockedRequest = getMockedRequest(); mockedResponse = getMockedResponse(); + CacheManager testCache = new CacheManager(); + Map> bpPerOwner = new HashMap>(); + bpPerOwner.put("xyz1731", (List)bpList2.items); + testCache.putObject("owner_bp_map", bpPerOwner); + subject.setCacheManager(testCache); + /* + PowerMockito.mockStatic(SystemProperties.class); + Mockito + .when(SystemProperties.getProperty("cache_switch")) + .thenReturn("1"); + */ } - public void getExpectedDeployments() - throws JsonParseException, JsonMappingException, IOException { - - deplItem = new Service("dcae_dtiapi_1902", null, "1552335532348", "1552335532348", null, - "dummyVnfId", null, "dummyVnfType", "dummyLocation", "dcae_dtiapi_1902", null); - Collection items = new ArrayList(); - items.add(deplItem); - - String pageLinks = - "{\"previousLink\":null,\"nextLink\":{\"rel\":\"next\",\"href\":\"https://invt.com:30123/dcae-services/?offset=25\"}}"; - ServiceList.PaginationLinks paginationLinks = - objectMapper.readValue(pageLinks, ServiceList.PaginationLinks.class); - int totalCount = 1; - deplList = new ServiceList(items, totalCount, paginationLinks); - - } - - public void getExpectedBueprints() + public void getExpectedBlueprints() throws JsonParseException, JsonMappingException, IOException { - bpItem = new ServiceType.Builder("xyz1731", "xyz1731-helm-1906", 1906, + bpItem = new ServiceTypeSummary.Builder().application("app1").component("comp1"). + typeName("xyz1731-helm-1906").owner("xyz1731").typeVersion(1906).build(); + + bpItem2 = new ServiceTypeSummary("xyz1731", "xyz1731-helm-1906", 1906, "app1", "comp1", "123-456-789", + "342343", true); + bpItemFull = new ServiceType.Builder("xyz1731", "xyz1731-helm-1906", 1906, "tosca_definitions_version: cloudify_dsl_1_3", "", "app1", "comp1").build(); - Collection items = new ArrayList(); + + Collection items = new ArrayList(); items.add(bpItem); + Collection items2 = new ArrayList(); + items2.add(bpItem2); + String pageLinks2 = "{\"previousLink\":null,\"nextLink\":{\"rel\":\"next\",\"href\":\"https://invt.com:30123/dcae-services/?offset=25\"}}"; - ServiceTypeList.PaginationLinks paginationLinks = - objectMapper.readValue(pageLinks2, ServiceTypeList.PaginationLinks.class); + ServiceTypeSummaryList.PaginationLinks paginationLinks = + objectMapper.readValue(pageLinks2, ServiceTypeSummaryList.PaginationLinks.class); int totalCount = 1; - bpList = new ServiceTypeList(items, totalCount, paginationLinks); + bpList = new ServiceTypeSummaryList(items, totalCount, paginationLinks); + bpList2 = new ServiceTypeSummaryList(items2, totalCount, paginationLinks); } public void createBpUploadItem() { - bpUploadItem = ServiceTypeRequest.from(bpItem); + bpUploadItem = ServiceTypeRequest.from(bpItemFull); } @After public void tearDown() throws Exception { } + @Test + public final void testGetOwnersByPage() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); + Collection items = bpList.items; + Stream sampleStream1 = items.stream(); + Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1); + String result = subject.getServiceTypesByPage(mockedRequest); + assertTrue(result.contains("xyz")); + } + + @Test + public final void testGetAllServiceTypeNames() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); + Collection items = bpList.items; + Stream sampleStream1 = items.stream(); + Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1); + String result = subject.getAllServiceTypeNames(mockedRequest); + assertTrue(result.contains("xyz")); + } + + @Test + public final void testGetAllServiceTypeIds() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); + Collection items = bpList.items; + Stream sampleStream1 = items.stream(); + Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1); + String result = subject.getAllServiceTypeIds(mockedRequest); + assertTrue(result.contains("xyz")); + } + @Test public final void testGetServiceTypesByPage() { User user = mockUser.mockUser(); user.setLoginId("tester"); MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); - mockedRequest.addParameter("searchBy", "xyz"); + //mockedRequest.addParameter("searchBy", "xyz"); mockedRequest.addParameter("sortBy", "owner"); + // # 1st case Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); - - Collection items = bpList.items; - - Stream sampleStream1 = items.stream(); + Collection items = bpList.items; + Stream sampleStream1 = items.stream(); Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1); String result = subject.getServiceTypesByPage(mockedRequest); assertTrue(result.contains("xyz")); - - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); - + + // # 2nd case HttpSession session = mockedRequest.getSession(); HashMap comp_deploy_tab = new HashMap(); comp_deploy_tab.put("comp1", true); - Set userApps = new TreeSet(); userApps.add("comp1"); - when(session.getAttribute("comp_access")).thenReturn(comp_deploy_tab); when(session.getAttribute("role_level")).thenReturn("app"); when(session.getAttribute("authComponents")).thenReturn(userApps); - Stream sampleStream2 = items.stream(); - Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) + Stream sampleStream2 = items.stream(); + Mockito.when(inventoryClient.getServiceTypes()) .thenReturn(sampleStream2); + /* + Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) + .thenReturn(sampleStream2); + */ String result2 = subject.getServiceTypesByPage(mockedRequest); assertTrue(result2.contains("xyz")); - } + } + @Test - public final void testGetServiceTypesByPage_appl() { + public final void testGetServiceTypesByPage_appDevUser() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); - mockedRequest.addParameter("sortBy", "application"); - - Collection items = bpList.items; - Stream sampleStream1 = items.stream(); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); + HttpSession session = mockedRequest.getSession(); + HashMap comp_deploy_tab = new HashMap(); + comp_deploy_tab.put("comp1", true); + Set userApps = new TreeSet(); + userApps.add("comp1"); + when(session.getAttribute("comp_access")).thenReturn(comp_deploy_tab); + when(session.getAttribute("role_level")).thenReturn("app_dev"); + when(session.getAttribute("authComponents")).thenReturn(userApps); - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); + Collection items = bpList.items; + Stream sampleStream = items.stream(); + Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream); - Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1); String result = subject.getServiceTypesByPage(mockedRequest); assertTrue(result.contains("xyz")); + } + + @Test + public final void testGetServiceTypesByPage_containsFilter() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + mockedRequest.addParameter("searchBy", "contains:xyz1731-helm-1906"); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); + Collection items = bpList.items; + Stream sampleStream = items.stream(); + Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream); - Stream sampleStream2 = items.stream(); - Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) - .thenReturn(sampleStream2); - String result2 = subject.getServiceTypesByPage(mockedRequest); - assertTrue(result2.contains("xyz")); + String result = subject.getServiceTypesByPage(mockedRequest); + assertTrue(result.contains("error")); } + + @Test + public final void testGetServiceTypesByPage_AllFilters() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + mockedRequest.addParameter("searchBy", "serviceRef:xyz1731-helm-1906;app:app1;comp:comp1;owner:xyz1731;"); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); + + Collection items = bpList.items; + Stream sampleStream = items.stream(); + Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream); + String result = subject.getServiceTypesByPage(mockedRequest); + assertTrue(result.contains("xyz")); + + } + @Test public final void testGetServiceTypesByPage_comp() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); mockedRequest.addParameter("sortBy", "component"); - Collection items = bpList.items; - Stream sampleStream1 = items.stream(); - - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); + Collection items = bpList2.items; + Stream sampleStream1 = items.stream(); Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1); String result = subject.getServiceTypesByPage(mockedRequest); assertTrue(result.contains("xyz")); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); - - Stream sampleStream2 = items.stream(); - Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) - .thenReturn(sampleStream2); - String result2 = subject.getServiceTypesByPage(mockedRequest); - assertTrue(result2.contains("xyz")); } @Test public final void testGetServiceTypesByPage_typeId() { + User user = mockUser.mockUser(); + user.setLoginId("tester"); MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); mockedRequest.addParameter("sortBy", "typeId"); - Collection items = bpList.items; - Stream sampleStream1 = items.stream(); - - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); + Collection items = bpList2.items; + Stream sampleStream1 = items.stream(); Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1); String result = subject.getServiceTypesByPage(mockedRequest); assertTrue(result.contains("xyz")); - - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); - - Stream sampleStream2 = items.stream(); - Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) - .thenReturn(sampleStream2); - String result2 = subject.getServiceTypesByPage(mockedRequest); - assertTrue(result2.contains("xyz")); } @Test public final void testGetServiceTypesByPage_typeName() { - + User user = mockUser.mockUser(); + user.setLoginId("tester"); MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); mockedRequest.addParameter("sortBy", "typeName"); - Collection items = bpList.items; - Stream sampleStream1 = items.stream(); - - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); - + Collection items = bpList2.items; + Stream sampleStream1 = items.stream(); Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1); String result = subject.getServiceTypesByPage(mockedRequest); assertTrue(result.contains("xyz")); - - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); - - Stream sampleStream2 = items.stream(); - Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) - .thenReturn(sampleStream2); - String result2 = subject.getServiceTypesByPage(mockedRequest); - assertTrue(result2.contains("xyz")); - } @Test public final void testGetServiceTypesByPage_typeVer() { - + User user = mockUser.mockUser(); + user.setLoginId("tester"); MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); mockedRequest.addParameter("sortBy", "typeVersion"); - Collection items = bpList.items; - Stream sampleStream1 = items.stream(); - - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); + Collection items = bpList2.items; + Stream sampleStream1 = items.stream(); Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1); String result = subject.getServiceTypesByPage(mockedRequest); assertTrue(result.contains("xyz")); - - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); - - Stream sampleStream2 = items.stream(); - Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) - .thenReturn(sampleStream2); - String result2 = subject.getServiceTypesByPage(mockedRequest); - assertTrue(result2.contains("xyz")); - } @Test public final void testGetServiceTypesByPage_created() { - + User user = mockUser.mockUser(); + user.setLoginId("tester"); MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); mockedRequest.addParameter("sortBy", "created"); - Collection items = bpList.items; - Stream sampleStream1 = items.stream(); - - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); + Collection items = bpList2.items; + Stream sampleStream1 = items.stream(); Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream1); String result = subject.getServiceTypesByPage(mockedRequest); assertTrue(result.contains("xyz")); - - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); - - Stream sampleStream2 = items.stream(); - Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) - .thenReturn(sampleStream2); - String result2 = subject.getServiceTypesByPage(mockedRequest); - assertTrue(result2.contains("xyz")); } - @Test - public final void testGetServiceTypesByPage_Auth() { - - User user = mockUser.mockUser(); - user.setLoginId("tester"); - MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); - mockedRequest.addParameter("searchBy", "xyz"); - - Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); - - Collection items = bpList.items; - Stream sampleStream = items.stream(); - - HttpSession session = mockedRequest.getSession(); - HashMap comp_deploy_tab = new HashMap(); - comp_deploy_tab.put("comp1", true); - - Set userApps = new TreeSet(); - userApps.add("comp1"); - - when(session.getAttribute("comp_access")).thenReturn(comp_deploy_tab); - when(session.getAttribute("role_level")).thenReturn("ops"); - when(session.getAttribute("authComponents")).thenReturn(userApps); - - Mockito.when(inventoryClient.getServiceTypes(Matchers.any())) - .thenReturn(sampleStream); - String result = subject.getServiceTypesByPage(mockedRequest); - assertTrue(result.contains("xyz")); - } @SuppressWarnings("unchecked") @Test public final void testGetServiceTypesByPage_Exception() { - PowerMockito.mockStatic(DashboardProperties.class); - Collection items = bpList.items; - Stream sampleStream = items.stream(); - when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); when(inventoryClient.getServiceTypes()).thenThrow(RestClientException.class) - .thenThrow(httpException).thenReturn(sampleStream); + .thenThrow(httpException); String errResp = subject.getServiceTypesByPage(mockedRequest); assertTrue(errResp.contains("error")); errResp = subject.getServiceTypesByPage(mockedRequest); assertTrue(errResp.contains("error")); - - String result = subject.getServiceTypesByPage(mockedRequest); - assertTrue(result.contains("xyz")); - } - - @Test - public final void testGetServiceTypesByPage_Filter() { - User user = mockUser.mockUser(); - user.setLoginId("tester"); - MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); - mockedRequest.addParameter("searchBy", "xyz"); - PowerMockito.mockStatic(DashboardProperties.class); - Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user); - - Collection items = bpList.items; - Stream sampleStream = items.stream(); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); - Mockito.when(inventoryClient.getServiceTypes()).thenReturn(sampleStream); - - String result = subject.getServiceTypesByPage(mockedRequest); - assertTrue(result.contains("xyz")); } - @Test - public final void testGetServicesByPage_auth() throws IOException { - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); - MockHttpServletRequestWrapper mockedRequest1 = getMockedRequest(); - mockedRequest1.addParameter("searchBy", "dti"); - Collection items = deplList.items; - - HttpSession session = mockedRequest1.getSession(); - HashMap comp_deploy_tab = new HashMap(); - comp_deploy_tab.put("dcae", true); - - Set userApps = new TreeSet(); - userApps.add("dcae"); - - when(session.getAttribute("comp_access")).thenReturn(comp_deploy_tab); - when(session.getAttribute("role_level")).thenReturn("app"); - when(session.getAttribute("authComponents")).thenReturn(userApps); - - Stream sampleStream1 = items.stream(); - Mockito.when(inventoryClient.getServices()).thenReturn(sampleStream1); - - String result1 = subject.getServicesByPage(mockedRequest1); - assertTrue(result1.contains("dti")); - - } - - @Test - public final void testGetServicesByPage_auth_ops() throws IOException { - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); - MockHttpServletRequestWrapper mockedRequest1 = getMockedRequest(); - mockedRequest1.addParameter("searchBy", "dti"); - - Collection items = deplList.items; - - HttpSession session = mockedRequest1.getSession(); - HashMap comp_deploy_tab = new HashMap(); - comp_deploy_tab.put("dcae", true); - - Set userApps = new TreeSet(); - userApps.add("dcae"); - - when(session.getAttribute("comp_access")).thenReturn(comp_deploy_tab); - when(session.getAttribute("role_level")).thenReturn("ops"); - when(session.getAttribute("authComponents")).thenReturn(userApps); - - Stream sampleStream1 = items.stream(); - Mockito.when(inventoryClient.getServices()).thenReturn(sampleStream1); - - String result1 = subject.getServicesByPage(mockedRequest1); - assertTrue(result1.contains("dti")); - - } - - @Test - public final void testGetServicesByPage() throws IOException { - /* - * User user = mockUser.mockUser(); user.setLoginId("tester"); - */ - MockHttpServletRequestWrapper mockedRequest1 = getMockedRequest(); - mockedRequest1.addParameter("searchBy", "dti"); - mockedRequest1.addParameter("sortBy", "deploymentRef"); - - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); - - Collection items = deplList.items; - - Stream sampleStream1 = items.stream(); - Mockito.when(inventoryClient.getServices()).thenReturn(sampleStream1); - - String result1 = subject.getServicesByPage(mockedRequest1); - assertTrue(result1.contains("dti")); - } - - @Test - public final void testGetServicesByPage_sort_serviceId() throws IOException { - - MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); - mockedRequest.addParameter("sortBy", "serviceId"); - - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); - - Collection items = deplList.items; - - Stream sampleStream1 = items.stream(); - Mockito.when(inventoryClient.getServices()).thenReturn(sampleStream1); - - String result = subject.getServicesByPage(mockedRequest); - assertTrue(result.contains("dti")); - - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); - - Stream sampleStream2 = items.stream(); - Mockito.when(inventoryClient.getServices()).thenReturn(sampleStream2); - - String result2 = subject.getServicesByPage(mockedRequest); - assertTrue(result2.contains("dti")); - } - - @Test - public final void testGetServicesByPage_sort_created() throws IOException { - MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); - mockedRequest.addParameter("sortBy", "created"); - - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); - - Collection items = deplList.items; - - Stream sampleStream = items.stream(); - Mockito.when(inventoryClient.getServices()).thenReturn(sampleStream); - - String result = subject.getServicesByPage(mockedRequest); - assertTrue(result.contains("dti")); - - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); - - Stream sampleStream2 = items.stream(); - Mockito.when(inventoryClient.getServices()).thenReturn(sampleStream2); - - String result2 = subject.getServicesByPage(mockedRequest); - assertTrue(result2.contains("dti")); - - } - - @Test - public final void testGetServicesByPage_sort_modified() throws IOException { - - MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); - mockedRequest.addParameter("sortBy", "modified"); - - PowerMockito.mockStatic(DashboardProperties.class); - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("os"); - - Collection items = deplList.items; - - Stream sampleStream = items.stream(); - Mockito.when(inventoryClient.getServices()).thenReturn(sampleStream); - - String result = subject.getServicesByPage(mockedRequest); - assertTrue(result.contains("dti")); - - Mockito - .when(DashboardProperties.getPropertyDef(DashboardProperties.CONTROLLER_TYPE, "auth")) - .thenReturn("auth"); - - Stream sampleStream2 = items.stream(); - Mockito.when(inventoryClient.getServices()).thenReturn(sampleStream2); - - String result2 = subject.getServicesByPage(mockedRequest); - assertTrue(result2.contains("dti")); - } @SuppressWarnings("unchecked") @Test @@ -670,38 +444,36 @@ public class InventoryControllerTest extends MockitoTestSuite { .thenThrow(BlueprintParseException.class).thenThrow(httpException) .thenThrow(Exception.class).thenReturn(null); - String actual1 = subject.updateServiceTypeBlueprint(mockedRequest, bpItem); + String actual1 = subject.updateServiceTypeBlueprint(mockedRequest, bpItemFull); assertTrue(actual1.contains("error")); - String actual2 = subject.updateServiceTypeBlueprint(mockedRequest, bpItem); + String actual2 = subject.updateServiceTypeBlueprint(mockedRequest, bpItemFull); assertTrue(actual2.contains("error")); - String actual3 = subject.updateServiceTypeBlueprint(mockedRequest, bpItem); + String actual3 = subject.updateServiceTypeBlueprint(mockedRequest, bpItemFull); assertTrue(actual3.contains("error")); - String actual = subject.updateServiceTypeBlueprint(mockedRequest, bpItem); + String actual = subject.updateServiceTypeBlueprint(mockedRequest, bpItemFull); assertEquals(expected, actual); } - @Test - public final void testDeleteService() throws Exception { - String expected = "{\"202\": \"OK\"}"; - doNothing().doThrow(serviceException).doThrow(Exception.class).when(inventoryClient) - .deleteService(Matchers.anyString()); - - String actual = subject.deleteService("srvcId", mockedRequest, mockedResponse); - assertEquals(expected, actual); - - actual = subject.deleteService("srvcId", mockedRequest, mockedResponse); - assertTrue(actual.contains("error")); - - actual = subject.deleteService("srvcId", mockedRequest, mockedResponse); - assertTrue(actual.contains("error")); - } - @Test public final void testDeleteServiceType() throws Exception { - String expected = "{\"202\": \"OK\"}"; + //String expected = "{\"202\": \"OK\"}"; + String expected = "{\"204\": \"Blueprint deleted\"}"; + List deplForBp = new ArrayList<>(); + deplForBp.clear(); + Mockito.when(cfyClient.getDeploymentForBlueprint(Matchers.any())) + .thenReturn(deplForBp); + + List srvcRefList = new ArrayList<>(); + srvcRefList.clear(); + int itemCnt = 0; + ServiceRefList mockSvcRefList = new ServiceRefList(srvcRefList, itemCnt); + + Mockito.when(inventoryClient.getServicesForType(Matchers.any())) + .thenReturn(mockSvcRefList); + doNothing().doThrow(serviceTypeException).doThrow(Exception.class).when(inventoryClient) .deleteServiceType(Matchers.anyString()); @@ -715,10 +487,24 @@ public class InventoryControllerTest extends MockitoTestSuite { assertTrue(actual.contains("error")); } + @Test + public final void testDeleteServiceType_withDepl() throws Exception { + CloudifyDeployedTenant mockCfyDeplTen = + new CloudifyDeployedTenant("id1", "tenant", "45435435", "54543534"); + + List deplForBp = new ArrayList<>(); + deplForBp.add(mockCfyDeplTen); + Mockito.when(cfyClient.getDeploymentForBlueprint(Matchers.any())) + .thenReturn(deplForBp); + + String actual = subject.deleteServiceType("srvcId", mockedRequest, mockedResponse); + assertTrue(actual.contains("error")); + } + @SuppressWarnings("unchecked") @Test public final void testViewServiceTypeBlueprintContentById() throws Exception { - Optional expected = Optional.of(bpItem); + Optional expected = Optional.of(bpItemFull); when(inventoryClient.getServiceType(Matchers.anyString())).thenReturn(expected) .thenThrow(httpException).thenThrow(Exception.class); diff --git a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/model/ControllerOpsToolsTest.java b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/model/ControllerOpsToolsTest.java deleted file mode 100644 index 001df8d..0000000 --- a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/model/ControllerOpsToolsTest.java +++ /dev/null @@ -1,44 +0,0 @@ -/******************************************************************************* - * =============LICENSE_START========================================================= - * - * ================================================================================= - * Copyright (c) 2019 AT&T Intellectual Property. All rights reserved. - * - * Modifications Copyright (C) 2019 IBM. - * ================================================================================ - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * ============LICENSE_END========================================================= - * - * ECOMP is a trademark and service mark of AT&T Intellectual Property. - *******************************************************************************/ -package org.onap.ccsdk.dashboard.model; - -import static org.junit.Assert.*; - -import org.junit.Test; - -public class ControllerOpsToolsTest { - - ControllerOpsTools co; - private String id="123"; - private String url="http//google.com"; - - @Test - public void testControllerOpsTools() { - ControllerOpsTools co= new ControllerOpsTools(); - ControllerOpsTools co1= new ControllerOpsTools(id,url); - assertEquals("123",co1.getId()); - assertEquals("http//google.com",co1.getUrl()); - } - -} diff --git a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/CloudifyRestClientImplTest.java b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/CloudifyRestClientImplTest.java index a5c5cf8..68223da 100644 --- a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/CloudifyRestClientImplTest.java +++ b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/CloudifyRestClientImplTest.java @@ -31,8 +31,14 @@ import static org.mockito.Mockito.when; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; +import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Set; +import java.util.TreeSet; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; import org.junit.Before; import org.junit.Ignore; @@ -43,28 +49,32 @@ import org.mockito.Matchers; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.MockitoAnnotations; -import org.onap.ccsdk.dashboard.model.CloudifyBlueprint; -import org.onap.ccsdk.dashboard.model.CloudifyBlueprintList; -import org.onap.ccsdk.dashboard.model.CloudifyDeployedTenant; -import org.onap.ccsdk.dashboard.model.CloudifyDeployedTenantList; -import org.onap.ccsdk.dashboard.model.CloudifyDeployment; -import org.onap.ccsdk.dashboard.model.CloudifyDeploymentList; -import org.onap.ccsdk.dashboard.model.CloudifyDeploymentUpdateRequest; -import org.onap.ccsdk.dashboard.model.CloudifyDeploymentUpdateResponse; -import org.onap.ccsdk.dashboard.model.CloudifyEvent; -import org.onap.ccsdk.dashboard.model.CloudifyEventList; -import org.onap.ccsdk.dashboard.model.CloudifyEventList.Metadata; -import org.onap.ccsdk.dashboard.model.CloudifyExecution; -import org.onap.ccsdk.dashboard.model.CloudifyExecutionList; -import org.onap.ccsdk.dashboard.model.CloudifyExecutionRequest; -import org.onap.ccsdk.dashboard.model.CloudifyNodeId; -import org.onap.ccsdk.dashboard.model.CloudifyNodeIdList; -import org.onap.ccsdk.dashboard.model.CloudifyNodeInstance; -import org.onap.ccsdk.dashboard.model.CloudifyNodeInstanceId; -import org.onap.ccsdk.dashboard.model.CloudifyNodeInstanceIdList; -import org.onap.ccsdk.dashboard.model.CloudifyNodeInstanceList; -import org.onap.ccsdk.dashboard.model.CloudifyTenantList; +import org.onap.ccsdk.dashboard.core.MockitoTestSuite; +import org.onap.ccsdk.dashboard.core.MockitoTestSuite.MockHttpServletRequestWrapper; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyBlueprint; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyBlueprintList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeployedTenant; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeployedTenantList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeployment; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeploymentList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyEvent; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyEventList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyEventList.Metadata; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyExecution; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyExecutionList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyExecutionRequest; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeId; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeIdList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeInstance; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeInstanceId; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeInstanceIdList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyNodeInstanceList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyPlugin; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyPluginList; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifySecret; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyTenantList; import org.onap.ccsdk.dashboard.util.DashboardProperties; +import org.onap.portalsdk.core.util.CacheManager; import org.powermock.api.mockito.PowerMockito; import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.modules.junit4.PowerMockRunner; @@ -83,23 +93,27 @@ import com.fasterxml.jackson.datatype.jdk8.Jdk8Module; @RunWith(PowerMockRunner.class) @PrepareForTest({DashboardProperties.class}) -public class CloudifyRestClientImplTest { +public class CloudifyRestClientImplTest extends MockitoTestSuite { @Mock RestTemplate mockRest; @InjectMocks CloudifyRestClientImpl subject = new CloudifyRestClientImpl(); - - protected final ObjectMapper objectMapper = new ObjectMapper(); + + HttpServletRequest mockedRequest; + HttpServletResponse mockedResponse; + protected final static ObjectMapper objectMapper = new ObjectMapper(); @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); objectMapper.registerModule(new Jdk8Module()); PowerMockito.mockStatic(DashboardProperties.class); - when(DashboardProperties.getControllerProperty("dev", - DashboardProperties.CONTROLLER_SUBKEY_URL)).thenReturn("https://orcl.com"); + when(DashboardProperties.getControllerProperty("site.primary", + DashboardProperties.SITE_SUBKEY_CLOUDIFY_URL)).thenReturn("https://orcl.com"); + CacheManager testCache = new CacheManager(); + subject.setCacheManager(testCache); this.subject.init(); } @@ -287,32 +301,11 @@ public class CloudifyRestClientImplTest { assertTrue(actualResult.items.get(0).id.equals("node_instance_id1")); } - @Test - public final void testGetTenantInfoFromDeploy() { - - CloudifyDeployedTenant cldDeplTenant = new CloudifyDeployedTenant("id1", "bp1", "tenant1"); - List cldDeplTenantItems = new ArrayList(); - cldDeplTenantItems.add(cldDeplTenant); - CloudifyDeployedTenantList cldDeployedTenantList = - new CloudifyDeployedTenantList(cldDeplTenantItems, null); - - ResponseEntity response = - new ResponseEntity(cldDeployedTenantList, HttpStatus.OK); - - when(mockRest.exchange(Matchers.contains("deployments"), Matchers.eq(HttpMethod.GET), - Matchers.>any(), - Matchers.>any())) - .thenReturn(response); - - CloudifyDeployedTenantList actualResults = subject.getTenantInfoFromDeploy("tenant1"); - assertTrue(actualResults.items.get(0).blueprint_id.equals("bp1")); - } - @Test public void testGetExecutions() { CloudifyExecution cldExecution = - new CloudifyExecution("successful", "created_at", "install", false, "bp1", "id1", - "tenant1", "error", "execution_id1", null, false, false); + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, + "bp1", "id1","tenant1", "error", "execution_id1", null); List cldExecutionList = new ArrayList(); @@ -336,8 +329,8 @@ public class CloudifyRestClientImplTest { @Test public void testGetExecutionsSummary() { CloudifyExecution cldExecution = - new CloudifyExecution("successful", "created_at", "install", false, "bp1", "id1", - "tenant1", "error", "execution_id1", null, false, false); + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); List cldExecutionList = new ArrayList(); @@ -361,8 +354,8 @@ public class CloudifyRestClientImplTest { @Test public void testStartExecution() { - CloudifyExecution cfyExecObj = new CloudifyExecution("successful", "created_at", "install", - false, "bp1", "id1", "tenant1", "error", "execution_id1", null, false, false); + CloudifyExecution cfyExecObj = new CloudifyExecution("successful", "created_at", "ended-at", "install", + false, "bp1", "id1", "tenant1", "error", "execution_id1", null); Map params = new HashMap(); params.put("key1", "value1"); @@ -377,30 +370,11 @@ public class CloudifyRestClientImplTest { assertTrue(actualResult.status.equals("successful")); } - @Test - public void testUpdateDeployment() { - CloudifyDeploymentUpdateRequest cfyDeployUpdateReq = - new CloudifyDeploymentUpdateRequest("deployment_id", "update", false, false, - "node_instance_id1", "4", "1000", "image", 2, "my_container"); - - CloudifyDeploymentUpdateResponse cfyDeployUpdateResp = new CloudifyDeploymentUpdateResponse( - "terminated", "created_at", "update", false, "blueprint_id", "deployment_id", "", "id1", - null, "tenant1", "junit", false, "resource_availability"); - - when(mockRest.postForObject(Matchers.anyString(), Matchers.>any(), - Matchers.>any())) - .thenReturn(cfyDeployUpdateResp); - - CloudifyDeploymentUpdateResponse actualResult = - subject.updateDeployment(cfyDeployUpdateReq); - assertTrue(actualResult.status.equals("terminated")); - } - @Test @Ignore public void testCancelExecution() { - CloudifyExecution cfyExecObj = new CloudifyExecution("successful", "created_at", "install", - false, "bp1", "id1", "tenant1", "error", "execution_id1", null, false, false); + CloudifyExecution cfyExecObj = new CloudifyExecution("successful", "created_at", "end_at", "install", + false, "bp1", "id1", "tenant1", "error", "execution_id1", null); Map params = new HashMap(); params.put("key1", "value1"); @@ -421,7 +395,6 @@ public class CloudifyRestClientImplTest { } @Test - @Ignore public void testGetBlueprint() { CloudifyBlueprint cldBp = new CloudifyBlueprint("file1", "description1", "343242", "3423423", "id1", null); @@ -441,16 +414,39 @@ public class CloudifyRestClientImplTest { doReturn(response).when(mockRest).exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), Matchers.>any(), - Matchers.>any()); + Matchers.>any()); CloudifyBlueprintList actualResult = subject.getBlueprint("id1", "tenant1"); assertTrue(actualResult.items.get(0).id.equals("id1")); } @Test - @Ignore public void testGetDeployments() { + CloudifyDeployment cldDeployment = new CloudifyDeployment("description", "blueprint_id", + "created_at", "updated_at", "id", null, null, null, null, null, null, null, "tenant"); + List cfyDeployItems = new ArrayList(); + cfyDeployItems.add(cldDeployment); + + CloudifyDeploymentList.Metadata.Pagination pageObj = + new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); + CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); + + CloudifyDeploymentList cldDeployList = new CloudifyDeploymentList(cfyDeployItems, metadata); + + ResponseEntity response = + new ResponseEntity(cldDeployList, HttpStatus.OK); + + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.>any())) + .thenReturn(response); + + CloudifyDeploymentList actualResult = subject.getDeployments("tenant", 10, 0); + assertTrue(actualResult.items.get(0).id.equals("id")); + } + + @Test + public void testGetDeployments_from_cache() { CloudifyDeployment cldDeployment = new CloudifyDeployment("description", "blueprint_id", "created_at", "updated_at", "id", null, null, null, null, null, null, null, "tenant"); @@ -466,11 +462,380 @@ public class CloudifyRestClientImplTest { ResponseEntity response = new ResponseEntity(cldDeployList, HttpStatus.OK); - when(mockRest.exchange(Matchers.contains("deploy"), Matchers.eq(HttpMethod.GET), - Matchers.>any(), Matchers.>any())) + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.>any())) .thenReturn(response); + + List actualResult = subject.getDeployments("tenant", 10, 0, true, true); + assertTrue(actualResult.get(0).id.equals("id")); + } + + @Test + public void testGetDeploymentForBlueprint() { + CloudifyDeployedTenant cfyDepTenant = + new CloudifyDeployedTenant("id", "tenant", "created_at", "updated_at"); + List cfyDepTenantList = new ArrayList<>(); + cfyDepTenantList.add(cfyDepTenant); + + CloudifyDeployedTenantList.Metadata.Pagination pageObj = + new CloudifyDeployedTenantList.Metadata.Pagination(1, 0, 1); + CloudifyDeployedTenantList.Metadata metadata = new CloudifyDeployedTenantList.Metadata(pageObj); + + CloudifyDeployedTenantList cldDeployList = new CloudifyDeployedTenantList(cfyDepTenantList, metadata); - CloudifyDeploymentList actualResult = subject.getDeployments(); + ResponseEntity response = + new ResponseEntity(cldDeployList, HttpStatus.OK); + + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())) + .thenReturn(response); + + List actuals = subject.getDeploymentForBlueprint("bpId"); + assertTrue(actuals.get(0).id.equals("id")); + } + + @Test + public void testGetDeploymentResource() { + CloudifyDeployment cldDeployment = new CloudifyDeployment("description", "blueprint_id", + "created_at", "updated_at", "id", null, null, null, null, null, null, null, "tenant"); + + List cfyDeployItems = new ArrayList(); + cfyDeployItems.add(cldDeployment); + + CloudifyDeploymentList.Metadata.Pagination pageObj = + new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); + CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); + + CloudifyDeploymentList cldDeployList = new CloudifyDeploymentList(cfyDeployItems, metadata); + + ResponseEntity response = + new ResponseEntity(cldDeployList, HttpStatus.OK); + + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.>any())) + .thenReturn(response); + + CloudifyDeployment actualResult = subject.getDeploymentResource("id", "tenant"); + assertTrue(actualResult.id.equals("id")); + } + + @Test + public void testGetNodeInstanceDetails() { + CloudifyNodeInstance cfyNodeInstance = new CloudifyNodeInstance("id1", null); + + List cfyNodeInstanceItems = new ArrayList(); + cfyNodeInstanceItems.add(cfyNodeInstance); + + CloudifyNodeInstanceList cfyNodeInstList = + new CloudifyNodeInstanceList(cfyNodeInstanceItems, null); + + ResponseEntity response2 = + new ResponseEntity(cfyNodeInstList, HttpStatus.OK); + when(mockRest.exchange(Matchers.contains("node-instances"), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())) + .thenReturn(response2); + + CloudifyNodeInstanceList actualResult = + subject.getNodeInstanceDetails("id", "tenant"); + assertTrue(actualResult.items.get(0).id.equals("id1")); + } + + @Test + public void testGetNodeInstances() { + CloudifyNodeInstanceId cfyNodeInstance = new CloudifyNodeInstanceId("id1"); + + List cfyNodeInstanceItems = new ArrayList(); + cfyNodeInstanceItems.add(cfyNodeInstance); + + CloudifyNodeInstanceIdList cfyNodeInstList = + new CloudifyNodeInstanceIdList(cfyNodeInstanceItems, null); + + ResponseEntity response2 = + new ResponseEntity(cfyNodeInstList, HttpStatus.OK); + when(mockRest.exchange(Matchers.contains("node-instances"), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())) + .thenReturn(response2); + + CloudifyNodeInstanceIdList actualResult = + subject.getNodeInstances("id", "tenant"); + assertTrue(actualResult.items.get(0).id.equals("id1")); + } + + + @Test + public void testGetExecutionsSummaryPerTenant() { + CloudifyExecution cldExecution = + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); + + List cldExecutionList = new ArrayList(); + + cldExecutionList.add(cldExecution); + + CloudifyExecutionList cloudifyExecutionList = + new CloudifyExecutionList(cldExecutionList, null); + + ResponseEntity response = + new ResponseEntity(cloudifyExecutionList, HttpStatus.OK); + + when(mockRest.exchange(Matchers.contains("include"), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())) + .thenReturn(response); + + CloudifyExecutionList actualResult = + subject.getExecutionsSummaryPerTenant("tenant1"); + assertTrue(actualResult.items.get(0).id.contains("id1")); + } + + @Test + public void testGetExecutionIdSummary() { + CloudifyExecution cldExecution = + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); + ResponseEntity response = + new ResponseEntity(cldExecution, HttpStatus.OK); + when(mockRest.exchange(Matchers.contains("include"), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())) + .thenReturn(response); + CloudifyExecution actuals = subject.getExecutionIdSummary("execution_id1", "tenant"); + assertTrue(actuals.id.contains("execution_id1")); + } + + @Test + public void testGetInstallExecutionSummary() { + CloudifyExecution cldExecution = + new CloudifyExecution("successful", "created_at", "ended_at", "install", false, "bp1", "id1", + "tenant1", "error", "execution_id1", null); + + List cldExecutionList = new ArrayList(); + + cldExecutionList.add(cldExecution); + + CloudifyExecutionList cloudifyExecutionList = + new CloudifyExecutionList(cldExecutionList, null); + + ResponseEntity response = + new ResponseEntity(cloudifyExecutionList, HttpStatus.OK); + + when(mockRest.exchange(Matchers.contains("include"), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())) + .thenReturn(response); + + CloudifyExecutionList actualResult = + subject.getInstallExecutionSummary("id1", "tenant1"); + assertTrue(actualResult.items.get(0).id.contains("id1")); + } + + @Test + public void testViewBlueprint() { + byte[] outArr = "Any String you want".getBytes(); + ResponseEntity response = + new ResponseEntity(outArr, HttpStatus.OK); + + doReturn(response).when(mockRest).exchange(Matchers.anyString(), + Matchers.eq(HttpMethod.GET), Matchers.>any(), + Matchers.>any()); + + subject.viewBlueprint("tenant1", "id1"); + } + + @Test + public void testGetDeploymentNamesWithFilter() throws Exception { + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + //mockedRequest.addParameter("filters", filterStr); + //mockedRequest.addParameter("sort", "name"); + Set userRoleSet = new HashSet(); + Set userApps = new TreeSet<>(); + userRoleSet.add("Standard User"); + userRoleSet.add("ECOMPC_DCAE_WRITE"); + userApps.add("dcae"); + + Mockito.when(mockedRequest.getAttribute("userRoles")).thenReturn(userRoleSet); + Mockito.when(mockedRequest.getAttribute("userApps")).thenReturn(userApps); + + String tenantsList = + "{\"items\": [{\"id\": 1, \"dName\": null, \"name\": \"default_tenant\"}, {\"id\": 2, \"dName\": null, \"name\": \"dyh1b1902\"}], \"metadata\": {\"pagination\": {\"total\": 2, \"offset\": 0, \"size\": 0}}}"; + CloudifyTenantList sampleData = null; + try { + sampleData = objectMapper.readValue(tenantsList, CloudifyTenantList.class); + } catch (Exception e) { + } + + ResponseEntity response1 = + new ResponseEntity(sampleData, HttpStatus.OK); + + + CloudifyDeployment cldDeployment = new CloudifyDeployment("description", "blueprint_id", + "created_at", "updated_at", "id", null, null, null, null, null, null, null, "tenant"); + + List cfyDeployItems = new ArrayList(); + cfyDeployItems.add(cldDeployment); + + CloudifyDeploymentList.Metadata.Pagination pageObj = + new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); + CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); + + CloudifyDeploymentList cldDeployList = new CloudifyDeploymentList(cfyDeployItems, metadata); + + ResponseEntity response2 = + new ResponseEntity(cldDeployList, HttpStatus.OK); + + Mockito + .when(mockRest.exchange(Matchers.contains("tenants"), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())) + .thenReturn(response1); + + Mockito.when(mockRest.exchange(Matchers.contains("deployments"), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.>any())) + .thenReturn(response2); + + List actual = subject.getDeploymentNamesWithFilter(mockedRequest); + assertTrue(actual.size() > 0); + } + + @Test + public void testGetDeploymentsWithFilter() throws Exception { + MockHttpServletRequestWrapper mockedRequest = getMockedRequest(); + //mockedRequest.addParameter("filters", filterStr); + //mockedRequest.addParameter("sort", "name"); + Set userRoleSet = new HashSet(); + Set userApps = new TreeSet<>(); + userRoleSet.add("Standard User"); + userRoleSet.add("ECOMPC_DCAE_WRITE"); + userApps.add("dcae"); + + Mockito.when(mockedRequest.getAttribute("userRoles")).thenReturn(userRoleSet); + Mockito.when(mockedRequest.getAttribute("userApps")).thenReturn(userApps); + + String tenantsList = + "{\"items\": [{\"id\": 1, \"dName\": null, \"name\": \"default_tenant\"}, {\"id\": 2, \"dName\": null, \"name\": \"dyh1b1902\"}], \"metadata\": {\"pagination\": {\"total\": 2, \"offset\": 0, \"size\": 0}}}"; + CloudifyTenantList sampleData = null; + try { + sampleData = objectMapper.readValue(tenantsList, CloudifyTenantList.class); + } catch (Exception e) { + } + + ResponseEntity response1 = + new ResponseEntity(sampleData, HttpStatus.OK); + + + CloudifyDeployment cldDeployment = new CloudifyDeployment("description", "blueprint_id", + "created_at", "updated_at", "id", null, null, null, null, null, null, null, "tenant"); + + List cfyDeployItems = new ArrayList(); + cfyDeployItems.add(cldDeployment); + + CloudifyDeploymentList.Metadata.Pagination pageObj = + new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); + CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); + + CloudifyDeploymentList cldDeployList = new CloudifyDeploymentList(cfyDeployItems, metadata); + + ResponseEntity response2 = + new ResponseEntity(cldDeployList, HttpStatus.OK); + + Mockito + .when(mockRest.exchange(Matchers.contains("tenants"), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())) + .thenReturn(response1); + + Mockito.when(mockRest.exchange(Matchers.contains("deployments"), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.>any())) + .thenReturn(response2); + + List actuals = subject.getDeploymentsWithFilter(mockedRequest); + assertTrue(actuals.size() > 0); + } + + @Test + public void testGetSecret() { + String secretTokenStr = + "{\"created_at\": \"created_ts\", \"key\": \"acl_key\", \"updated_at\": \"updated_ts\", \"value\": \"acl_token_val\", \"visibility\": \"global\", \"is_hidden_value\": \"false\", \"tenant_name\": \"tenant\", \"resource_availability\": \"rsrc\"}"; + CloudifySecret sampleData = null; + try { + sampleData = objectMapper.readValue(secretTokenStr, CloudifySecret.class); + } catch (Exception e) { + + } + + ResponseEntity response = + new ResponseEntity(sampleData, HttpStatus.OK); + + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())) + .thenReturn(response); + + CloudifySecret actuals = subject.getSecret("acl_key", "tenant"); + assertTrue(actuals.getKey().equals("acl_key")); + } + + @Test + public void testDeleteBlueprint() { + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE), + Matchers.>any(), + Matchers.>any())).thenReturn(null); + subject.deleteBlueprint("bp", "tenant"); + } + + @Test + public void testGetPlugins() { + CloudifyPlugin sampleData = + new CloudifyPlugin("plugin1", "202001", "linux", "linux_k8s_plugin", "20200801"); + + List cfyPlugins = new ArrayList(); + cfyPlugins.add(sampleData); + + CloudifyPluginList.Metadata.Pagination pageObj = + new CloudifyPluginList.Metadata.Pagination(1, 0, 1); + CloudifyPluginList.Metadata metadata = new CloudifyPluginList.Metadata(pageObj); + + CloudifyPluginList cfyPluginList = new CloudifyPluginList(cfyPlugins, metadata); + ResponseEntity response = + new ResponseEntity(cfyPluginList, HttpStatus.OK); + + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())) + .thenReturn(response); + + CloudifyPluginList actuals = subject.getPlugins(); + assertTrue(actuals.items.get(0).package_name.equals("plugin1")); + } + + @Test + public void testGetDeploymentInputs() { + CloudifyDeployment cldDeployment = new CloudifyDeployment("description", "blueprint_id", + "created_at", "updated_at", "id", null, null, null, null, null, null, null, "tenant"); + + List cfyDeployItems = new ArrayList(); + cfyDeployItems.add(cldDeployment); + + CloudifyDeploymentList.Metadata.Pagination pageObj = + new CloudifyDeploymentList.Metadata.Pagination(1, 0, 1); + CloudifyDeploymentList.Metadata metadata = new CloudifyDeploymentList.Metadata(pageObj); + + CloudifyDeploymentList cldDeployList = new CloudifyDeploymentList(cfyDeployItems, metadata); + + ResponseEntity response = + new ResponseEntity(cldDeployList, HttpStatus.OK); + + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.>any())) + .thenReturn(response); + + CloudifyDeploymentList actualResult = subject.getDeploymentInputs("id", "tenant"); assertTrue(actualResult.items.get(0).id.equals("id")); } + + } + diff --git a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/ConsulRestClientImplTest.java b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/ConsulRestClientImplTest.java index f90afa9..7d85196 100644 --- a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/ConsulRestClientImplTest.java +++ b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/ConsulRestClientImplTest.java @@ -23,26 +23,30 @@ package org.onap.ccsdk.dashboard.rest; import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; import static org.mockito.Mockito.when; +import java.net.MalformedURLException; +import java.net.URL; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; -import org.json.JSONObject; import org.junit.After; import org.junit.Before; -import org.junit.Ignore; +import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; import org.mockito.Matchers; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import org.onap.ccsdk.dashboard.model.ConsulDatacenter; -import org.onap.ccsdk.dashboard.model.ConsulNodeInfo; -import org.onap.ccsdk.dashboard.model.ConsulServiceHealth; -import org.onap.ccsdk.dashboard.model.ConsulServiceInfo; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifySecret; +import org.onap.ccsdk.dashboard.model.consul.ConsulDatacenter; +import org.onap.ccsdk.dashboard.model.consul.ConsulDeploymentHealth; +import org.onap.ccsdk.dashboard.model.consul.ConsulNodeInfo; +import org.onap.ccsdk.dashboard.model.consul.ConsulServiceHealth; +import org.onap.ccsdk.dashboard.model.consul.ConsulServiceInfo; import org.onap.ccsdk.dashboard.util.DashboardProperties; import org.powermock.api.mockito.PowerMockito; import org.powermock.core.classloader.annotations.PrepareForTest; @@ -64,36 +68,91 @@ public class ConsulRestClientImplTest { @Mock RestTemplate mockRest; - + @InjectMocks - ConsulRestClientImpl subject = new ConsulRestClientImpl(); + ConsulRestClientImpl subject; + + String[] svcTags = {"cfytenantname=onap"}; + + protected final static ObjectMapper objectMapper = new ObjectMapper(); + static HttpClientErrorException httpException; - protected final ObjectMapper objectMapper = new ObjectMapper(); - HttpClientErrorException httpException; + @BeforeClass + public static void setUpBeforeClass() throws Exception { + httpException = new HttpClientErrorException(HttpStatus.FORBIDDEN, "statusText"); + objectMapper.registerModule(new Jdk8Module()); + } + @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); - objectMapper.registerModule(new Jdk8Module()); - httpException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "statusText"); PowerMockito.mockStatic(DashboardProperties.class); - when(DashboardProperties.getControllerProperty("dev", - DashboardProperties.CONTROLLER_SUBKEY_CONSUL_URL)).thenReturn("https://invt.com"); - this.subject.init(); + when(DashboardProperties.getControllerProperty("site.primary", + DashboardProperties.SITE_SUBKEY_CONSUL_URL)).thenReturn("https://cnsl-svc.com"); + when(DashboardProperties.getControllerProperty("site.primary", + DashboardProperties.SITE_SUBKEY_CLOUDIFY_URL)).thenReturn("https://orcl-svc.com"); + when(DashboardProperties.getControllerProperty("site.primary", + DashboardProperties.SITE_SUBKEY_CLOUDIFY_USERNAME)).thenReturn("admin"); + when(DashboardProperties.getControllerProperty("site.primary", + DashboardProperties.SITE_SUBKEY_CLOUDIFY_PASS)).thenReturn("admin"); + subject.setConsul_acl_token("consul_acl_token_for_dash"); + subject.init(); } @After public void tearDown() throws Exception { } + @Test + public final void testGetConsulAcl() { + String secretTokenStr = + "{\"created_at\": \"created_ts\", \"key\": \"acl_key\", \"updated_at\": \"updated_ts\", \"value\": \"acl_token_val\", \"visibility\": \"global\", \"is_hidden_value\": \"false\", \"tenant_name\": \"tenant\", \"resource_availability\": \"rsrc\"}"; + CloudifySecret sampleData = null; + try { + sampleData = objectMapper.readValue(secretTokenStr, CloudifySecret.class); + } catch (Exception e) { + } + + ResponseEntity response = + new ResponseEntity(sampleData, HttpStatus.OK); + + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())) + .thenReturn(response); + String actualSecretStr = subject.getConsulAcl(mockRest); + assertTrue(actualSecretStr.equals("acl_token_val")); + } + + @Test(expected = Exception.class) + public final void testCreateCfyRestTemplate() throws Exception { + String webapiUrl = DashboardProperties.getControllerProperty("site.primary", + DashboardProperties.SITE_SUBKEY_CLOUDIFY_URL); + String user = DashboardProperties.getControllerProperty("site.primary", + DashboardProperties.SITE_SUBKEY_CLOUDIFY_USERNAME); + String pass = DashboardProperties.getControllerProperty("site.primary", + DashboardProperties.SITE_SUBKEY_CLOUDIFY_PASS); + URL url = null; + try { + url = new URL(webapiUrl); + } catch (MalformedURLException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + String urlScheme = webapiUrl.split(":")[0]; + subject.createCfyRestTemplate(url, user, pass, urlScheme); + } + @Test public final void testGetServiceHealth() { ConsulServiceHealth consulSrvcHlth = new ConsulServiceHealth("cjlvmcnsl00", "service:pgaas1_Service_ID", "Service 'pgaasServer1' check", "passing", "This is a pgaas1_Service_ID health check", - "HTTP GET http://srvc.com:8000/healthcheck/status: 200 OK Output: { \"output\": \"Thu Apr 20 19:53:01 UTC 2017|INFO|masters=1 pgaas1.com|secondaries=0 |maintenance= |down=1 pgaas2.com| \" }\n", - "pgaas1_Service_ID", "pgaasServer1", 190199, 199395); + "OK Output:", + "pgaas1_Service_ID", "pgaasServer1", svcTags, 34234, 4234); + // new ConsulServiceHealth() List expectedCnslSrvcHlth = new ArrayList(); expectedCnslSrvcHlth.add(consulSrvcHlth); @@ -109,21 +168,47 @@ public class ConsulRestClientImplTest { assertTrue(actualCnslSrvcHlth.get(0).node.equals("cjlvmcnsl00")); } + @Test(expected = Exception.class) + public final void get_svc_health_rest_client_exception() { + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>>any())) + .thenThrow(httpException); + + subject.getServiceHealth("dc1", "srvc1"); + } + + @Test(expected = Exception.class) + public final void get_services_rest_client_exception() { + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>>any())) + .thenThrow(httpException); + subject.getServices("dc1"); + } + @Test - @Ignore public final void testGetServices() { List srvcIps = new ArrayList(); srvcIps.add("135.91.224.136"); srvcIps.add("135.91.224.138"); ConsulServiceInfo consulSrvcInfo = new ConsulServiceInfo("pgaasServer1", srvcIps); + Map respObj = new HashMap(); + respObj.put("pgaasServer1", srvcIps); + List expectedCnslSrvcs = new ArrayList(); expectedCnslSrvcs.add(consulSrvcInfo); - // ResponseEntity> response = new ResponseEntity>(consulSrvcInfo); + ResponseEntity> response = + new ResponseEntity>(respObj, HttpStatus.OK); + + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>>any())).thenReturn(response); - subject.getServices("dc1"); + List actualSvcList = subject.getServices("dc1"); + assertTrue(actualSvcList.get(0).name.equals("pgaasServer1")); } @Test @@ -146,13 +231,22 @@ public class ConsulRestClientImplTest { } + @Test(expected = Exception.class) + public final void get_nodes_rest_client_exception() { + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>>any())) + .thenThrow(httpException); + subject.getNodes("dc1"); + } + @Test public final void testGetNodeServicesHealth() { ConsulServiceHealth consulSrvcHlth = new ConsulServiceHealth("cjlvmcnsl00", "service:pgaas1_Service_ID", "Service 'pgaasServer1' check", "passing", "This is a pgaas1_Service_ID health check", "HTTP GET http://srvc.com:8000/healthcheck/status: 200 OK Output: { \"output\": \"Thu Apr 20 19:53:01 UTC 2017|INFO|masters=1 pgaas1.com|secondaries=0 |maintenance= |down=1 pgaas2.com| \" }\n", - "pgaas1_Service_ID", "pgaasServer1", 190199, 199395); + "pgaas1_Service_ID", "pgaasServer1", svcTags, 190199, 199395); List expectedCnslSrvcHlth = new ArrayList(); expectedCnslSrvcHlth.add(consulSrvcHlth); @@ -170,6 +264,15 @@ public class ConsulRestClientImplTest { assertTrue(actualNodeHlthList.get(0).node.equals("cjlvmcnsl00")); } + @Test(expected = Exception.class) + public final void get_node_svc_rest_client_exception() { + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>>any())) + .thenThrow(httpException); + subject.getNodeServicesHealth("dc1", "nodeId1"); + } + @Test public final void testGetDatacenters() { ConsulDatacenter cnslDc = new ConsulDatacenter("dc1"); @@ -189,24 +292,45 @@ public class ConsulRestClientImplTest { assertTrue(actualDcList.get(0).name.equals("dc1")); } - @Test - @Ignore - public final void testRegisterService() { - fail("Not yet implemented"); // TODO + @Test(expected = Exception.class) + public final void get_dc_rest_client_exception() { + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>>any())) + .thenThrow(httpException); + subject.getDatacenters(); } - + @Test - public final void testDeregisterService() { + public final void testGetServiceHealthByDeploymentId() { + ConsulServiceHealth consulSrvcHlth = new ConsulServiceHealth("cjlvmcnsl00", + "service:pgaas1_Service_ID", "Service 'pgaasServer1' check", "passing", + "This is a pgaas1_Service_ID health check", + "HTTP GET http://srvc.com:8000/healthcheck/status: 200 OK Output: { \"output\": \"Thu Apr 20 19:53:01 UTC 2017|INFO|masters=1 pgaas1.com|secondaries=0 |maintenance= |down=1 pgaas2.com| \" }\n", + "pgaas1_Service_ID", "pgaasServer1", svcTags, 190199, 199395); - JSONObject jsonResp = new JSONObject(); + List expectedCnslSrvcHlth = new ArrayList(); + expectedCnslSrvcHlth.add(consulSrvcHlth); - ResponseEntity result = new ResponseEntity(jsonResp, HttpStatus.OK); - when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.PUT), - Matchers.>any(), Matchers.>any())) - .thenReturn(result); + ResponseEntity> response = + new ResponseEntity>(expectedCnslSrvcHlth, HttpStatus.OK); - int actualCode = subject.deregisterService("service1"); - assertTrue(actualCode == 200); - } + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>>any())) + .thenReturn(response); + ConsulDeploymentHealth cdh = subject.getServiceHealthByDeploymentId("deploymentId"); + assertTrue(cdh.getNode().equals("cjlvmcnsl00")); + } + + @Test(expected = Exception.class) + public final void get_svc_health_by_depId_rest_client_exception() { + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>>any())) + .thenThrow(httpException); + subject.getServiceHealthByDeploymentId("deploymentId"); + } + } diff --git a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/DeploymentHandlerClientImplTest.java b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/DeploymentHandlerClientImplTest.java index 7bd085b..2024d72 100644 --- a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/DeploymentHandlerClientImplTest.java +++ b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/DeploymentHandlerClientImplTest.java @@ -36,17 +36,20 @@ import org.junit.runner.RunWith; import org.mockito.InjectMocks; import org.mockito.Matchers; import org.mockito.Mock; +import org.mockito.MockitoAnnotations; import org.onap.ccsdk.dashboard.exceptions.BadRequestException; import org.onap.ccsdk.dashboard.exceptions.DeploymentNotFoundException; import org.onap.ccsdk.dashboard.exceptions.DownstreamException; import org.onap.ccsdk.dashboard.exceptions.ServerErrorException; import org.onap.ccsdk.dashboard.exceptions.ServiceAlreadyExistsException; +import org.onap.ccsdk.dashboard.model.cloudify.CloudifyDeployment; import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentLink; import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentRequest; import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentResponse; import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentResponseLinks; import org.onap.ccsdk.dashboard.model.deploymenthandler.DeploymentsListResponse; import org.onap.ccsdk.dashboard.util.DashboardProperties; +import org.onap.portalsdk.core.util.CacheManager; import org.powermock.api.mockito.PowerMockito; import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.modules.junit4.PowerMockRunner; @@ -66,22 +69,42 @@ public class DeploymentHandlerClientImplTest { @Mock RestTemplate mockRest; + @Mock + CloudifyClient cfyClient; + @InjectMocks DeploymentHandlerClientImpl subject; @Before public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); PowerMockito.mockStatic(DashboardProperties.class); - when(DashboardProperties.getControllerProperty("dev", - DashboardProperties.CONTROLLER_SUBKEY_DHANDLER_URL)).thenReturn("https://dplh.com"); + when(DashboardProperties.getControllerProperty("site.primary", + DashboardProperties.SITE_SUBKEY_DHANDLER_URL)).thenReturn("https://dplh.com"); + CacheManager testCache = new CacheManager(); + subject.setCacheManager(testCache); this.subject.init(); - } @After public void tearDown() throws Exception { } + @Test + public final void testCheckHealth() { + String expectStr = "DH mS health check"; + ResponseEntity response = + new ResponseEntity(expectStr, HttpStatus.OK); + + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())).thenReturn(response) + .thenReturn(response); + + String actualStr = subject.checkHealth(); + assertTrue(actualStr.equals(expectStr)); + } + @Test public final void testGetDeployments() { Collection expectedDeplRefs = new ArrayList(); @@ -205,93 +228,6 @@ public class DeploymentHandlerClientImplTest { subject.putDeployment("dpl12", "tenant12", deplReq); } - @Test - public final void testUpdateDeployment() throws Exception { - DeploymentRequest deplReq = new DeploymentRequest("serviceTypeId", null); - - DeploymentResponseLinks newDeplItemLink = - new DeploymentResponseLinks("selfUrl", "statusUrl"); - DeploymentResponse expectedDeplItem = new DeploymentResponse("req1", newDeplItemLink); - - ResponseEntity response = - new ResponseEntity(expectedDeplItem, HttpStatus.OK); - - when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.PUT), - Matchers.>any(), - Matchers.>any())).thenReturn(response); - - DeploymentResponse actualResponse = subject.updateDeployment("dpl12", "tenant12", deplReq); - assertTrue(actualResponse.getRequestId().equals("req1")); - } - - @Test(expected = DownstreamException.class) - public final void testUpdateDeployment_downstreamError() throws Exception { - - DeploymentRequest deplReq = new DeploymentRequest("serviceTypeId", null); - - HttpServerErrorException httpException = - new HttpServerErrorException(HttpStatus.BAD_GATEWAY, "statusText"); - - when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.PUT), - Matchers.>any(), - Matchers.>any())) - .thenThrow(httpException); - - subject.updateDeployment("dpl12", "tenant12", deplReq); - - } - - @Test(expected = BadRequestException.class) - public final void testUpdateDeployment_badReqError() throws Exception { - - DeploymentRequest deplReq = new DeploymentRequest("serviceTypeId", null); - - HttpClientErrorException httpException = - new HttpClientErrorException(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "statusText"); - - when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.PUT), - Matchers.>any(), - Matchers.>any())) - .thenThrow(httpException); - - subject.updateDeployment("dpl12", "tenant12", deplReq); - - } - - @Test(expected = ServiceAlreadyExistsException.class) - public final void testUpdateDeployment_srvcExistError() throws Exception { - - DeploymentRequest deplReq = new DeploymentRequest("serviceTypeId", null); - - HttpClientErrorException httpException = - new HttpClientErrorException(HttpStatus.CONFLICT, "statusText"); - - when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.PUT), - Matchers.>any(), - Matchers.>any())) - .thenThrow(httpException); - - subject.updateDeployment("dpl12", "tenant12", deplReq); - - } - - @Test(expected = ServerErrorException.class) - public final void testUpdateDeployment_srvcError() throws Exception { - - DeploymentRequest deplReq = new DeploymentRequest("serviceTypeId", null); - - HttpServerErrorException httpException = - new HttpServerErrorException(HttpStatus.INTERNAL_SERVER_ERROR, "statusText"); - - when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.PUT), - Matchers.>any(), - Matchers.>any())) - .thenThrow(httpException); - - subject.updateDeployment("dpl12", "tenant12", deplReq); - - } - @Test public final void testDeleteDeployment() throws Exception { DeploymentResponseLinks newDeplItemLink = @@ -305,6 +241,12 @@ public class DeploymentHandlerClientImplTest { Matchers.>any(), Matchers.>any())).thenReturn(response); + CloudifyDeployment cfyDepl = + new CloudifyDeployment("description", "blueprint_id", "created_at", "updated_at", + "id", null, null, null, null, null, null, null, "tenant_name"); + + when(cfyClient.getDeploymentResource(Matchers.anyString(), Matchers.anyString())).thenReturn(cfyDepl); + subject.deleteDeployment("deploymentId", "tenant"); } diff --git a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/RestInventoryClientImplTest.java b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/RestInventoryClientImplTest.java index d4c5e14..e0452d0 100644 --- a/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/RestInventoryClientImplTest.java +++ b/ccsdk-app-common/src/test/java/org/onap/ccsdk/dashboard/rest/RestInventoryClientImplTest.java @@ -30,6 +30,9 @@ import static org.mockito.Mockito.when; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.stream.Stream; @@ -52,7 +55,11 @@ import org.onap.ccsdk.dashboard.model.inventory.ServiceType; import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeList; import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeQueryParams; import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeRequest; +import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeServiceMap; +import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeSummary; +import org.onap.ccsdk.dashboard.model.inventory.ServiceTypeSummaryList; import org.onap.ccsdk.dashboard.util.DashboardProperties; +import org.onap.portalsdk.core.util.CacheManager; import org.powermock.api.mockito.PowerMockito; import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.modules.junit4.PowerMockRunner; @@ -84,9 +91,13 @@ public class RestInventoryClientImplTest { ServiceList deplListNext = null; Service deplItem = null; - ServiceType bpItem = null; - ServiceTypeList bpList = null; - ServiceTypeList bpListNext = null; + ServiceTypeSummary bpItem, bpItem2 = null; + ServiceTypeSummaryList bpList, bpList2 = null; + + ServiceType bpItemFull = null; + ServiceTypeList bpItemFullList = null; + + ServiceTypeSummaryList bpListNext = null; ServiceTypeRequest bpUploadItem = null; @@ -94,11 +105,13 @@ public class RestInventoryClientImplTest { public void setUp() throws Exception { MockitoAnnotations.initMocks(this); objectMapper.registerModule(new Jdk8Module()); - getExpectedBueprints(); + getExpectedBlueprints(); getExpectedDeployments(); PowerMockito.mockStatic(DashboardProperties.class); - when(DashboardProperties.getControllerProperty("dev", - DashboardProperties.CONTROLLER_SUBKEY_INVENTORY_URL)).thenReturn("https://invt.com"); + when(DashboardProperties.getControllerProperty("site.primary", + DashboardProperties.SITE_SUBKEY_INVENTORY_URL)).thenReturn("https://invt.com"); + CacheManager testCache = new CacheManager(); + subject.setCacheManager(testCache); this.subject.init(); } @@ -122,96 +135,124 @@ public class RestInventoryClientImplTest { ServiceList.PaginationLinks paginationLinks2 = objectMapper.readValue(pageLinks2, ServiceList.PaginationLinks.class); - int totalCount = 2; - deplList = new ServiceList(items, totalCount, paginationLinks); + int totalCount = 1; + deplList = new ServiceList(items, totalCount, paginationLinks2); deplListNext = new ServiceList(items, totalCount, paginationLinks2); } - - public void getExpectedBueprints() + + public void getExpectedBlueprints() throws JsonParseException, JsonMappingException, IOException { - bpItem = new ServiceType.Builder("xyz1731", "xyz1731-helm-1906", 1906, + + bpItem = new ServiceTypeSummary.Builder().application("app1").component("comp1"). + typeName("xyz1731-helm-1906").owner("xyz1731").typeVersion(1906).build(); + + bpItem2 = new ServiceTypeSummary("xyz1731", "xyz1731-helm-1906", 1906, "app1", "comp1", "123-456-789", + "342343", true); + bpItemFull = new ServiceType.Builder("xyz1731", "xyz1731-helm-1906", 1906, "tosca_definitions_version: cloudify_dsl_1_3", "", "app1", "comp1").build(); - Collection items = new ArrayList(); - items.add(bpItem); + Collection items = new ArrayList(); + items.add(bpItem); + Collection items2 = new ArrayList(); + items2.add(bpItem2); + String pageLinks = - "{\"previousLink\":null,\"nextLink\":{\"rel\":\"next\",\"href\":\"https://invt.com:30123/dcae-services/?offset=25\"}}"; + "{\"previousLink\":null,\"nextLink\":{\"rel\":\"next\",\"href\":\"https://invt.com:30123/dcae-service-types/?offset=25\"}}"; String pageLinks2 = "{\"previousLink\":null,\"nextLink\":null}"; - ServiceTypeList.PaginationLinks paginationLinks = - objectMapper.readValue(pageLinks, ServiceTypeList.PaginationLinks.class); - ServiceTypeList.PaginationLinks paginationLinks2 = - objectMapper.readValue(pageLinks2, ServiceTypeList.PaginationLinks.class); + ServiceTypeSummaryList.PaginationLinks paginationLinks = + objectMapper.readValue(pageLinks, ServiceTypeSummaryList.PaginationLinks.class); + ServiceTypeSummaryList.PaginationLinks paginationLinks2 = + objectMapper.readValue(pageLinks2, ServiceTypeSummaryList.PaginationLinks.class); int totalCount = 2; - bpList = new ServiceTypeList(items, totalCount, paginationLinks); - bpListNext = new ServiceTypeList(items, totalCount, paginationLinks2); + bpList = new ServiceTypeSummaryList(items, totalCount, paginationLinks); + bpList2 = new ServiceTypeSummaryList(items2, totalCount, paginationLinks); + bpListNext = new ServiceTypeSummaryList(items, totalCount, paginationLinks2); } @Test - @Ignore - public final void testInit() { - fail("Not yet implemented"); // TODO + public final void testCheckHealth() { + String expectStr = "Inventory mS health check"; + ResponseEntity response = + new ResponseEntity(expectStr, HttpStatus.OK); + + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())).thenReturn(response) + .thenReturn(response); + + String actualStr = subject.checkHealth(); + assertTrue(actualStr.equals(expectStr)); } @Test public final void testGetServiceTypes() { - /* - * String serviceTypeStr = - * "{\"paginationLinks\":{\"previousLink\":null,\"nextLink\":null}},\"totalCount\":32,\"items\":[{\"owner\":\"xyz1731\",\"typeName\":\"xyz1731-helm-1906\",\"typeVersion\":1906,\"blueprintTemplate\":\"tosca_definitions_version: cloudify_dsl_1_3\\nimports:\\n - http://www.getcloudify.org/spec/cloudify/4.2/types.yaml\\n - http://dockercentral.it.att.com:8093/nexus/repository/rawcentral/com.att.dcae.controller/type_files/helm/3.0.1/helm-type.yaml\\ninputs:\\n deployment-description:\\n default: ''\\n chart-name:\\n default: ''\\n tiller-server:\\n default: ''\\n tiller-server-port:\\n default: ''\\n namespace:\\n default: ''\\n chart-repo-url:\\n default: http://32.68.14.161/charts\\n chart-version :\\n default: ''\\n config-url:\\n default: ''\\n config-format:\\n default: ''\\n tls-enable:\\n description: enable helm TSL\\n type: boolean\\n default: false\\n config-dir:\\n description: config dir\\n type: string\\n default: '/opt/manager/resources/'\\n stable-repo-url:\\n description: URL for stable repository\\n type: string\\n default: 'http://32.68.14.161/stable'\\nnode_templates:\\n ecompcomponent:\\n type: onap.nodes.component\\n properties:\\n tiller-server-ip: { get_input: tiller-server }\\n tiller-server-port: { get_input: tiller-server-port }\\n component-name: { get_input: chart-name }\\n chart-repo-url: { concat: [ 'http://', { get_secret: controller_helm_user }, ':', { get_secret: controller_helm_password }, '@', { get_input: chart-repo-url } ] }\\n chart-version: { get_input: chart-version }\\n namespace: { get_input: namespace }\\n config-url: { concat: [ 'http://', { get_secret: controller_helm_user }, ':', { get_secret: controller_helm_password }, '@', { get_input: config-url } ] }\\n config-format: { get_input: config-format}\\n tls-enable: { get_input: tls-enable}\\n ca: { get_secret: ca_value}\\n cert: { get_secret: cert_value}\\n key: { get_secret: key_value}\\n config-dir: { get_input: config-dir}\\n stable-repo-url: { concat: [ 'http://', { get_secret: controller_helm_user }, ':', { get_secret: controller_helm_password }, '@', { get_input: stable-repo-url } ] }\\noutputs:\\n ecompcomponent-helm-output:\\n description: helm value and helm history\\n value:\\n helm-value: { get_attribute: [ecompcomponent, current-helm-value] }\\n helm-history: { get_attribute: [ecompcomponent, helm-history] }\",\"serviceIds\":[],\"vnfTypes\":[],\"serviceLocations\":[],\"asdcServiceId\":\"\",\"asdcResourceId\":\"\",\"asdcServiceURL\":null,\"application\":\"ECOMP\",\"component\":\"controller\",\"typeId\":\"72b8577a-5043-43ab-9aa5-6808b8f53967\",\"selfLink\":{\"rel\":\"self\",\"href\":\"https://ecompc-invt-dev-s5.ecomp.idns.cip.att.com:30123/dcae-service-types/72b8577a-5043-43ab-9aa5-6808b8f53967\"},\"created\":1551214264536,\"deactivated\":null}]" - * ; ServiceTypeList sampleData = null; try { sampleData = - * objectMapper.readValue(serviceTypeStr, ServiceTypeList.class); } catch - * (Exception e) { } - */ - Collection items = bpList.items; - Stream expectedResult = items.stream(); - - ResponseEntity response = - new ResponseEntity(bpList, HttpStatus.OK); - - ResponseEntity response2 = - new ResponseEntity(bpListNext, HttpStatus.OK); + Collection items = bpList.items; + Stream expectedResult = items.stream(); + + ResponseEntity response = + new ResponseEntity(bpList, HttpStatus.OK); + + ResponseEntity response2 = + new ResponseEntity(bpListNext, HttpStatus.OK); when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), Matchers.>any(), - Matchers.>any())).thenReturn(response) + Matchers.>any())).thenReturn(response) .thenReturn(response2); - Stream actualResult = subject.getServiceTypes(); + Stream actualResult = subject.getServiceTypes(); assertNotNull(actualResult); assertTrue(expectedResult.count() == actualResult.count()); } + @Test + public final void testCacheServiceTypes() { + ResponseEntity response = + new ResponseEntity(bpList, HttpStatus.OK); + + ResponseEntity response2 = + new ResponseEntity(bpListNext, HttpStatus.OK); + + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())).thenReturn(response) + .thenReturn(response2); + + subject.cacheServiceTypes(); + } + @Test public final void testGetServiceTypesServiceTypeQueryParams() { ServiceTypeQueryParams qryParms = new ServiceTypeQueryParams.Builder() .asdcResourceId("asdcResourceId").asdcServiceId("asdcServiceId").onlyActive(true) .onlyLatest(false).serviceId("serviceId").serviceLocation("serviceLocation") .typeName("typeName").vnfType("vnfType").build(); - Collection items = bpList.items; - Stream expectedResult = items.stream(); + Collection items = bpList.items; + Stream expectedResult = items.stream(); - ResponseEntity response = - new ResponseEntity(bpList, HttpStatus.OK); + ResponseEntity response = + new ResponseEntity(bpList, HttpStatus.OK); - ResponseEntity response2 = - new ResponseEntity(bpListNext, HttpStatus.OK); + ResponseEntity response2 = + new ResponseEntity(bpListNext, HttpStatus.OK); when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), Matchers.>any(), - Matchers.>any())).thenReturn(response) + Matchers.>any())).thenReturn(response) .thenReturn(response2); - Stream actualResult = subject.getServiceTypes(qryParms); + Stream actualResult = subject.getServiceTypes(qryParms); assertNotNull(actualResult); assertTrue(expectedResult.count() == actualResult.count()); } @Test public final void testGetServiceType() { - Optional expectedResult = Optional.of(bpItem); + Optional expectedResult = Optional.of(bpItemFull); ResponseEntity response = - new ResponseEntity(bpItem, HttpStatus.OK); + new ResponseEntity(bpItemFull, HttpStatus.OK); when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), Matchers.>any(), Matchers.>any())) @@ -222,140 +263,87 @@ public class RestInventoryClientImplTest { } @Test - public final void testAddServiceTypeServiceType() { - - when(mockRest.postForObject(Matchers.anyString(), Matchers.>any(), - Matchers.>any())).thenReturn(bpItem); - - ServiceType actualResult = subject.addServiceType(bpItem); - assertTrue(actualResult.getTypeName().contains("xyz")); - } - - @Test - public final void testAddServiceTypeServiceTypeRequest() { - ServiceTypeRequest srvcReq = ServiceTypeRequest.from(bpItem); - - when(mockRest.postForObject(Matchers.anyString(), Matchers.>any(), - Matchers.>any())).thenReturn(bpItem); - - ServiceType actualResult = subject.addServiceType(srvcReq); - assertTrue(actualResult.getTypeName().contains("xyz")); - } - - @Test - public final void testDeleteServiceType() throws Exception { - ResponseEntity response = - new ResponseEntity(HttpStatus.OK); - - when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE), - Matchers.>any(), - Matchers.>any())).thenReturn(response); - - subject.deleteServiceType("4243234"); - } - - @Test - public final void testGetServices() { - - Collection items = deplList.items; - Stream expectedResult = items.stream(); - + public final void testGetServicesForType() throws Exception { + String typeId = "44234234"; + ServiceRef expectedSrvc = new ServiceRef("dcae_dtiapi_1902", "432423", "433434"); + Collection expectedSrvcIds = new ArrayList(); + expectedSrvcIds.add(expectedSrvc); + ServiceRefList expectedSvcRefList = new ServiceRefList(expectedSrvcIds, 1); ResponseEntity response = new ResponseEntity(deplList, HttpStatus.OK); - ResponseEntity response2 = - new ResponseEntity(deplListNext, HttpStatus.OK); - when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), Matchers.>any(), Matchers.>any())) - .thenReturn(response).thenReturn(response2); - - Stream actualResult = subject.getServices(); - assertNotNull(actualResult); - assertTrue(expectedResult.count() == actualResult.count()); - - } - - @Test - public final void testGetServicesForType() { - ResponseEntity response = - new ResponseEntity(deplList, HttpStatus.OK); - - ResponseEntity response2 = - new ResponseEntity(deplListNext, HttpStatus.OK); - - when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), - Matchers.>any(), Matchers.>any())) - .thenReturn(response).thenReturn(response2); - ServiceQueryParams qryParms = new ServiceQueryParams.Builder().typeId("typeId").build(); - - ServiceRefList actualResult = subject.getServicesForType(qryParms); - assertTrue(actualResult.items.size() == 2); - ServiceRef actualSrvcItem = (ServiceRef) actualResult.items.toArray()[0]; - assertTrue(actualSrvcItem.getServiceId().contains("dtiapi")); - + .thenReturn(response); + + ServiceQueryParams qryParams = new ServiceQueryParams.Builder().typeId(typeId).build(); + ServiceRefList actualSvcRefList = subject.getServicesForType(qryParams); + assertTrue(actualSvcRefList.totalCount == expectedSvcRefList.totalCount); } - + @Test - public final void testGetServicesServiceQueryParams() { - ServiceQueryParams qryParms = new ServiceQueryParams.Builder().typeId("typeId") - .vnfId("vnfId").vnfLocation("vnfLocation").vnfType("vnfType") - .componentType("componentType").shareable(false).created("43443423").build(); - - Collection items = deplList.items; - Stream expectedResult = items.stream(); - - ResponseEntity response = - new ResponseEntity(deplList, HttpStatus.OK); - - ResponseEntity response2 = - new ResponseEntity(deplListNext, HttpStatus.OK); - - when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), - Matchers.>any(), Matchers.>any())) - .thenReturn(response).thenReturn(response2); + public final void testAddServiceTypeServiceType() { - Stream actualResult = subject.getServices(qryParms); - assertTrue(expectedResult.count() == actualResult.count()); - } + when(mockRest.postForObject(Matchers.anyString(), Matchers.>any(), + Matchers.>any())).thenReturn(bpItemFull); - @Test - public final void testGetService() { - Optional expectedResult = Optional.of(deplItem); + ResponseEntity response = + new ResponseEntity(bpList, HttpStatus.OK); - ResponseEntity response = new ResponseEntity(deplItem, HttpStatus.OK); + ResponseEntity response2 = + new ResponseEntity(bpListNext, HttpStatus.OK); when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), - Matchers.>any(), Matchers.>any())) - .thenReturn(response); - - Optional actualResult = subject.getService("432432423"); - assertTrue( - expectedResult.get().getDeploymentRef().equals(actualResult.get().getDeploymentRef())); + Matchers.>any(), + Matchers.>any())).thenReturn(response) + .thenReturn(response2); + + ServiceType actualResult = subject.addServiceType(bpItemFull); + assertTrue(actualResult.getTypeName().contains("xyz")); } @Test - public final void testPutService() { + public final void testAddServiceTypeServiceTypeRequest() { + ServiceTypeRequest srvcReq = ServiceTypeRequest.from(bpItemFull); - ResponseEntity response = new ResponseEntity(deplItem, HttpStatus.OK); + when(mockRest.postForObject(Matchers.anyString(), Matchers.>any(), + Matchers.>any())).thenReturn(bpItemFull); + + ResponseEntity response = + new ResponseEntity(bpList, HttpStatus.OK); - when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.PUT), - Matchers.>any(), Matchers.>any())) - .thenReturn(response); + ResponseEntity response2 = + new ResponseEntity(bpListNext, HttpStatus.OK); - subject.putService("423423", deplItem); + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())).thenReturn(response) + .thenReturn(response2); + ServiceType actualResult = subject.addServiceType(srvcReq); + assertTrue(actualResult.getTypeName().contains("xyz")); } @Test - public final void testDeleteService() throws Exception { + public final void testDeleteServiceType() throws Exception { ResponseEntity response = new ResponseEntity(HttpStatus.OK); when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE), Matchers.>any(), Matchers.>any())).thenReturn(response); + + ResponseEntity response1 = + new ResponseEntity(bpList, HttpStatus.OK); + + ResponseEntity response2 = + new ResponseEntity(bpListNext, HttpStatus.OK); - subject.deleteService("4243234"); + when(mockRest.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), + Matchers.>any())).thenReturn(response1) + .thenReturn(response2); + + subject.deleteServiceType("4243234"); } } -- cgit 1.2.3-korg