diff options
Diffstat (limited to 'test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/imports/ImportCsarResourceTest.java')
| -rw-r--r-- | test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/imports/ImportCsarResourceTest.java | 1751 |
1 files changed, 1751 insertions, 0 deletions
diff --git a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/imports/ImportCsarResourceTest.java b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/imports/ImportCsarResourceTest.java new file mode 100644 index 0000000000..1b559aaaad --- /dev/null +++ b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/imports/ImportCsarResourceTest.java @@ -0,0 +1,1751 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 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.openecomp.sdc.ci.tests.execute.imports; + +import static org.testng.AssertJUnit.assertEquals; +import static org.testng.AssertJUnit.assertNotNull; +import static org.testng.AssertJUnit.assertTrue; + +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +import org.apache.commons.codec.binary.Base64; +import org.apache.commons.lang.WordUtils; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.tinkerpop.gremlin.process.traversal.P; +import org.junit.Rule; +import org.junit.rules.TestName; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.ArtifactDefinition; +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.model.ComponentInstance; +import org.openecomp.sdc.be.model.ComponentInstanceProperty; +import org.openecomp.sdc.be.model.GroupDefinition; +import org.openecomp.sdc.be.model.GroupProperty; +import org.openecomp.sdc.be.model.RequirementCapabilityRelDef; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.be.model.Service; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.model.tosca.ToscaPropertyType; +import org.openecomp.sdc.ci.tests.api.ComponentBaseTest; +import org.openecomp.sdc.ci.tests.api.Urls; +import org.openecomp.sdc.ci.tests.config.Config; +import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails; +import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails; +import org.openecomp.sdc.ci.tests.datatypes.ImportReqDetails; +import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails; +import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails; +import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum; +import org.openecomp.sdc.ci.tests.datatypes.enums.ServiceCategoriesEnum; +import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum; +import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum; +import org.openecomp.sdc.ci.tests.datatypes.http.HttpRequest; +import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse; +import org.openecomp.sdc.ci.tests.utils.Utils; +import org.openecomp.sdc.ci.tests.utils.general.ElementFactory; +import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils; +import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils; +import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils; +import org.openecomp.sdc.ci.tests.utils.rest.GroupRestUtils; +import org.openecomp.sdc.ci.tests.utils.rest.ImportRestUtils; +import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils; +import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils; +import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser; +import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils; +import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils; +import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; +import org.openecomp.sdc.common.util.ValidationUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.testng.annotations.Test; + +import com.google.gson.Gson; + +public class ImportCsarResourceTest extends ComponentBaseTest { + private static Logger log = LoggerFactory.getLogger(ImportCsarResourceTest.class.getName()); + @Rule + public static TestName name = new TestName(); + + Gson gson = new Gson(); + + public ImportCsarResourceTest() { + super(name, ImportCsarResourceTest.class.getName()); + } + + private String buildAssertMessage(String expectedString, String actualString) { + return String.format("expected is : %s , actual is: %s", expectedString, actualString); + } + + /** + * + * User Story : US640615 [BE] - Extend create VF API with Import TOSCA CSAR + */ + + @Test(enabled = true) + public void createResourceFromCsarHappy() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("AF7F231969C5463F9C968570070E8877"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + + String expectedCsarUUID = resourceDetails.getCsarUUID(); + String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase()); + + assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, resource.getCsarUUID()), expectedCsarUUID.equals(resource.getCsarUUID())); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName())); + + RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId()); + Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class); + assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, getResource.getCsarUUID()), expectedCsarUUID.equals(getResource.getCsarUUID())); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName())); + } + + @Test(enabled = true) + public void emptyStringInCsarUUIDFieldTest() throws Exception { + String emptyString = ""; + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID(emptyString); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(null, resource.getComponentInstances()); + + String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase()); + + assertTrue("csarUUID : " + buildAssertMessage(emptyString, resource.getCsarUUID()), resource.getCsarUUID() == emptyString); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName())); + + RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId()); + Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class); + assertTrue("csarUUID : " + buildAssertMessage(emptyString, getResource.getCsarUUID()), getResource.getCsarUUID() == emptyString); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName())); + } + + @Test(enabled = true) + public void createResourceFromScratchTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(null, resource.getComponentInstances()); + + String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase()); + + assertTrue("csarUUID : " + buildAssertMessage(null, resource.getCsarUUID()), resource.getCsarUUID() == null); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName())); + + RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId()); + Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class); + assertTrue("csarUUID : " + buildAssertMessage(null, getResource.getCsarUUID()), getResource.getCsarUUID() == null); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName())); + } + + @Test(enabled = true) + public void fileNotCsarTypeTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("valid_vf_zip"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_NOT_FOUND.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void missingToscaMetadataFolderTest() throws Exception { + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("toscaFolderNotExists"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void missingToscaMetaFileTest() throws Exception { + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("toscaMetaFileNotExists"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void toscaMetaFileOutsideTheFolderTest() throws Exception { + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("toscaMetaOutsideTheFolder"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void caseSensitiveTest_1() throws Exception { + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("caseSensitiveTest_1"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void caseSensitiveTest_2() throws Exception { + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("caseSensitiveTest_2"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void missingOneLineInToscaMetaFileTest() throws Exception { + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("missingOneLineInToscaMeta"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void noCSARVersionTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("noCSARVersion"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void noCreatedByValueTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("noCreatedByValue"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void noEntryDefinitionsValueTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("noEntryDefinitionsValue"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void noTOSCAMetaFileVersionValueTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("noTOSCAMetaFileVersionValue"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void invalidCsarVersionInMetaFileTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("invalidCsarVersion"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + + resourceDetails.setCsarUUID("invalidCsarVersion2"); + createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + + resourceDetails.setCsarUUID("invalidCsarVersion3"); + createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + + resourceDetails.setCsarUUID("invalidCsarVersion4"); + createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + + resourceDetails.setCsarUUID("invalidCsarVersion5"); + createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + + } + + @Test(enabled = true) + public void validCsarVersionInMetaFileTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("validCsarVersion"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + + String expectedCsarUUID = resourceDetails.getCsarUUID(); + String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase()); + + assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, resource.getCsarUUID()), expectedCsarUUID.equals(resource.getCsarUUID())); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName())); + + RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId()); + Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class); + assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, getResource.getCsarUUID()), expectedCsarUUID.equals(getResource.getCsarUUID())); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName())); + } + + @Test(enabled = true) + public void underscoreInToscaMetaFileVersionNameTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("underscoreInsteadOfDash"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void missingEntryDefintionInMetaFileTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("missingEntryDefintionPair"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = false) + public void noNewLineAfterBLock0Test() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("noNewLineAfterBLock0"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void moreThanOneYamlFileTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("moreThenOneYamlFile"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + + String expectedCsarUUID = resourceDetails.getCsarUUID(); + String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase()); + + assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, resource.getCsarUUID()), expectedCsarUUID.equals(resource.getCsarUUID())); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName())); + + RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId()); + Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class); + assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, getResource.getCsarUUID()), expectedCsarUUID.equals(getResource.getCsarUUID())); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName())); + } + + @Test(enabled = true) + public void moreThanOneMetaFileTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("moreThanOneMetaFile"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + + String expectedCsarUUID = resourceDetails.getCsarUUID(); + String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase()); + + assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, resource.getCsarUUID()), expectedCsarUUID.equals(resource.getCsarUUID())); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName())); + + RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId()); + Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class); + assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, getResource.getCsarUUID()), expectedCsarUUID.equals(getResource.getCsarUUID())); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName())); + } + + @Test(enabled = true) + public void csarNotContainsYamlAndMetaFilesTest() throws Exception { + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("notContainYamlAndMetaFiles"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void csarNotContainsYamlFileTest() throws Exception { + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("notContainYamlFile"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + variables.add("Definitions/tosca_mock_vf.yaml"); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.YAML_NOT_FOUND_IN_CSAR.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void missingCsarFileTest() throws Exception { + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("abc"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_NOT_FOUND.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void longNamesInToscaMetaFileTest_1() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("longNamesInToscaMetaFile1"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void longNamesInToscaMetaFileTest_2() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("longNamesInToscaMetaFile2"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void longNamesInToscaMetaFileTest_3() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("longNamesInToscaMetaFile3"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void longNamesInToscaMetaFileTest_4() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("longNamesInToscaMetaFile4"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void longNamesInToscaMetaFileTest_5() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("longNamesInToscaMetaFile5"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + // possible to have more than four lines in block 0 + // @Test (enabled = true) + public void fiveLinesAsBlock0Test() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + resourceDetails.setCsarUUID("fiveLinesAsBlock0"); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + List<String> variables = new ArrayList<String>(); + variables.add(resourceDetails.getCsarUUID()); + ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse()); + } + + @Test(enabled = true) + public void lifecycleChangingToResourceFromCsarTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("valid_vf"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertTrue("0.1".equals(resource.getVersion())); + assertTrue(LifeCycleStatesEnum.CHECKOUT.getComponentState().equals(resource.getLifecycleState().toString())); + + String designerUserId = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER).getUserId(); + String testerUserId = ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getUserId(); + String csarUniqueId = resourceDetails.getUniqueId(); + assertNotNull(csarUniqueId); + + RestResponse lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKIN); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKOUT); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKIN); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CERTIFICATIONREQUEST); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUserId, LifeCycleStatesEnum.STARTCERTIFICATION); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUserId, LifeCycleStatesEnum.CERTIFY); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKOUT); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + + resource = ResponseParser.parseToObjectUsingMapper(lifecycleChangeResponse.getResponse(), Resource.class); + Map<String, String> allVersions = resource.getAllVersions(); + assertEquals(2, allVersions.keySet().size()); + assertEquals(2, allVersions.values().size()); + Set<String> keySet = allVersions.keySet(); + assertTrue(keySet.contains("1.0")); + assertTrue(keySet.contains("1.1")); + } + + @Test(enabled = true) + public void csarWithJsonPromEnvTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("VSPPackageJsonProp.csar"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + + } + + @Test(enabled = true) + public void uploadArtifactToResourceFromCsarTest() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("valid_vf"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + + User designer = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + ArtifactReqDetails artifactDetails = ElementFactory.getDefaultArtifact("firstArtifact"); + String firstArtifactLabel = artifactDetails.getArtifactLabel(); + RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(artifactDetails, designer, resourceDetails.getUniqueId()); + ArtifactRestUtils.checkSuccess(addInformationalArtifactToResource); + RestResponse getResourceResponse = ResourceRestUtils.getResource(resourceDetails.getUniqueId()); + Resource resource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class); + Map<String, ArtifactDefinition> informationalArtifacts = resource.getArtifacts(); + assertEquals(1, informationalArtifacts.keySet().size()); + Set<String> keySet = informationalArtifacts.keySet(); + assertTrue(keySet.contains(firstArtifactLabel.toLowerCase())); + Collection<ArtifactDefinition> values = informationalArtifacts.values(); + assertEquals(1, values.size()); + Iterator<ArtifactDefinition> iterator = values.iterator(); + while (iterator.hasNext()) { + ArtifactDefinition actualArtifact = iterator.next(); + assertTrue(firstArtifactLabel.equals(actualArtifact.getArtifactDisplayName())); + } + + RestResponse lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designer.getUserId(), LifeCycleStatesEnum.CHECKIN); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designer.getUserId(), LifeCycleStatesEnum.CHECKOUT); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + + ArtifactReqDetails artifactDetails2 = ElementFactory.getDefaultArtifact("secondArtifact"); + artifactDetails2.setArtifactName("secondArtifact"); + addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(artifactDetails2, designer, resourceDetails.getUniqueId()); + ArtifactRestUtils.checkSuccess(addInformationalArtifactToResource); + + getResourceResponse = ResourceRestUtils.getResource(resourceDetails.getUniqueId()); + resource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class); + informationalArtifacts = resource.getArtifacts(); + assertEquals(2, informationalArtifacts.keySet().size()); + keySet = informationalArtifacts.keySet(); + assertTrue(keySet.contains(firstArtifactLabel.toLowerCase())); + assertTrue(keySet.contains(artifactDetails2.getArtifactLabel().toLowerCase())); + values = informationalArtifacts.values(); + assertEquals(2, values.size()); + ArtifactDefinition[] actualArtifacts = values.toArray(new ArtifactDefinition[2]); + assertTrue(firstArtifactLabel.equals(actualArtifacts[0].getArtifactDisplayName())); + assertTrue(artifactDetails2.getArtifactLabel().equals(actualArtifacts[1].getArtifactDisplayName())); + } + + /* + * // @Test (enabled = true) public void createUpdateImportResourceFromCsarArtifactsWereNotChangedTest() throws Exception { // User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); // //back original scar RestResponse + * copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar"); BaseRestUtils.checkSuccess(copyRes); + * + * // resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); // RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); resourceDetails.setName("test5"); + * resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar"); resourceDetails.setCsarVersion("1"); // String invariantUUID = resource.getInvariantUUID(); // // RestResponse changeResourceState = + * LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); // assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + * + * // BaseRestUtils.checkSuccess(copyRes); // //change name (temporary) resourceDetails.setCsarVersion("2"); resourceDetails.setName("test6"); createResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, + * resourceDetails.getUniqueId()); Resource updatedResource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); Map<String, ArtifactDefinition> updatedArtifacts = updatedResource.getDeploymentArtifacts(); for + * (Entry<String, ArtifactDefinition> artifactEntry : resource.getDeploymentArtifacts().entrySet()) { if (updatedArtifacts.containsKey(artifactEntry.getKey())) { ArtifactDefinition currArt = updatedArtifacts.get(artifactEntry.getKey()); + * assertEquals(currArt.getArtifactVersion(), artifactEntry.getValue().getArtifactVersion()); assertEquals(currArt.getArtifactUUID(), artifactEntry.getValue().getArtifactUUID()); assertEquals(currArt.getArtifactChecksum(), + * artifactEntry.getValue().getArtifactChecksum()); } } // resourceDetails = ElementFactory.getDefaultResource(); // resourceDetails.setName("test5"); // resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar"); } + */ + + @Test(enabled = true) + public void createImportResourceFromCsarDissotiateArtifactFromGroupTest() throws Exception { + User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + RestResponse copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar"); + + // create new resource from Csar + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + String invariantUUID = resource.getInvariantUUID(); + + // add artifact from metadata (resource metadata should be updated) + // RestResponse addInformationalArtifactToResource = + // ArtifactRestUtils.addInformationalArtifactToResource(ElementFactory.getDefaultArtifact(), + // sdncModifierDetails, resourceDetails.getUniqueId()); + // ArtifactRestUtils.checkSuccess(addInformationalArtifactToResource); + resourceDetails.setName("test4"); + RestResponse updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId()); + BaseRestUtils.checkSuccess(updateResource); + resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class); + assertEquals(invariantUUID, resource.getInvariantUUID()); + + // wrong RI (without node types, resource shouldn't be updated) + copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_dissociate.csar", "VF_RI2_G4_withArtifacts.csar"); + BaseRestUtils.checkSuccess(copyRes); + // change name (temporary) + resourceDetails.setName("test4"); + updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId()); + BaseRestUtils.checkSuccess(updateResource); + resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class); + assertEquals(invariantUUID, resource.getInvariantUUID()); + + // back original scar + copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar"); + BaseRestUtils.checkSuccess(copyRes); + } + + @Test(enabled = true) + public void createImportResourceFromCsarNewgroupTest() throws Exception { + User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + RestResponse copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar"); + + // create new resource from Csar + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + String invariantUUID = resource.getInvariantUUID(); + + // update scar + copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_UpdateToscaAndArtifacts.csar", "VF_RI2_G4_withArtifacts.csar"); + BaseRestUtils.checkSuccess(copyRes); + + resourceDetails.setName("test2"); + // change resource metaData (resource should be updated) + resourceDetails.setDescription("It is new description bla bla bla"); + RestResponse updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId()); + BaseRestUtils.checkSuccess(updateResource); + resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + + assertEquals(invariantUUID, resource.getInvariantUUID()); + + copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar"); + BaseRestUtils.checkSuccess(copyRes); + } + + @Test(enabled = true) + public void createImportResourceFromCsarGetGroupTest() throws Exception { + User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + // RestResponse copyRes = + // copyCsarRest(sdncModifierDetails,"VF_RI2_G4_withArtifacts_a.csar","VF_RI2_G4_withArtifacts.csar"); + + // create new resource from Csar + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("VSPPackage"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + String invariantUUID = resource.getInvariantUUID(); + List<GroupDefinition> groups = resource.getGroups(); + + GroupDefinition groupWithArtifact = groups.stream().filter(p -> p.getArtifacts() != null && !p.getArtifacts().isEmpty()).findFirst().get(); + + RestResponse groupRest = GroupRestUtils.getGroupById(resource, groupWithArtifact.getUniqueId(), sdncModifierDetails); + BaseRestUtils.checkSuccess(groupRest); + + GroupDefinition groupWithoutArtifact = groups.stream().filter(p -> p.getArtifacts() == null || p.getArtifacts().isEmpty()).findFirst().get(); + + groupRest = GroupRestUtils.getGroupById(resource, groupWithoutArtifact.getUniqueId(), sdncModifierDetails); + BaseRestUtils.checkSuccess(groupRest); + } + + @Test(enabled = true) + public void createImportResourceFromCsarUITest() throws Exception { + RestResponse getResource = null; + User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + String payloadName = "valid_vf.csar"; + ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource(); + String rootPath = System.getProperty("user.dir"); + Path path = null; + byte[] data = null; + String payloadData = null; + + path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + + // create new resource from Csar + resourceDetails.setCsarUUID(payloadName); + resourceDetails.setPayloadName(payloadName); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + + RestResponse changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // change composition (resource should be updated) + path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf_b.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + // change name + resourceDetails.setName("test1"); + createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(2, resource.getComponentInstances().size()); + + changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // change name + resourceDetails.setName("test2"); + // change resource metaData (resource should be updated) + resourceDetails.setDescription("It is new description bla bla bla"); + createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(2, resource.getComponentInstances().size()); + + changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // wrong RI (without node types, resource shouldn't be updated) + path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf_c.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + // change name + resourceDetails.setName("test3"); + createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkErrorResponse(createResource, ActionStatus.INVALID_NODE_TEMPLATE, "Definitions/tosca_mock_vf.yaml", "nodejs", "tosca.nodes.Weber"); + resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(null, resource); + getResource = ResourceRestUtils.getResourceByNameAndVersion(sdncModifierDetails.getUserId(), "test3", resourceDetails.getVersion()); + BaseRestUtils.checkErrorResponse(getResource, ActionStatus.RESOURCE_NOT_FOUND, "test3"); + + // create new resource from other Csar + resourceDetails = ElementFactory.getDefaultImportResource(); + path = Paths.get(rootPath + "/src/main/resources/ci/VF_RI2_G4_withArtifacts.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + resourceDetails.setPayloadName("VF_RI2_G4_withArtifacts.csar"); + resourceDetails.setName("test4"); + resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + + changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // wrong RI (with node types) resource shouldn't be created + resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts_b.csar"); + path = Paths.get(rootPath + "/src/main/resources/ci/VF_RI2_G4_withArtifacts_b.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + resourceDetails.setPayloadName("VF_RI2_G4_withArtifacts_b.csar"); + resourceDetails.setName("test5"); + createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkErrorResponse(createResource, ActionStatus.INVALID_NODE_TEMPLATE, "Definitions/VF_RI2_G1.yaml", "ps04_port_0", "org.openecomp.resource.cp.nodes.heat.network.neutron.Portur"); + } + + @Test(enabled = true) + public void createUpdateImportResourceFromCsarUITest() throws Exception { + RestResponse getResource = null; + User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + String payloadName = "valid_vf.csar"; + ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource(); + String rootPath = System.getProperty("user.dir"); + Path path = null; + byte[] data = null; + String payloadData = null; + + path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + + // create new resource from Csar + resourceDetails.setPayloadName(payloadName); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + + RestResponse changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // change composition and update resource + path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf_b.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + resourceDetails.setUniqueId(resource.getUniqueId()); + // change name + RestResponse updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId()); + BaseRestUtils.checkSuccess(updateResource); + resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class); + assertEquals(2, resource.getComponentInstances().size()); + + changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // change name + resourceDetails.setName("test2"); + // change resource metaData (resource should be updated) + resourceDetails.setDescription("It is new description bla bla bla"); + updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId()); + BaseRestUtils.checkSuccess(updateResource); + resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class); + assertEquals(2, resource.getComponentInstances().size()); + + changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // try to update resource with wrong RI (without node types, resource + // shouldn't be updated) + path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf_c.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + // change name + resourceDetails.setName("test3"); + updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId()); + BaseRestUtils.checkErrorResponse(updateResource, ActionStatus.INVALID_NODE_TEMPLATE, "Definitions/tosca_mock_vf.yaml", "nodejs", "tosca.nodes.Weber"); + resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class); + assertEquals(null, resource); + getResource = ResourceRestUtils.getResourceByNameAndVersion(sdncModifierDetails.getUserId(), "test3", resourceDetails.getVersion()); + BaseRestUtils.checkErrorResponse(getResource, ActionStatus.RESOURCE_NOT_FOUND, "test3"); + } + + @Test(enabled = true) + public void createUpdateImportResourceFromCsarTest() throws Exception { + User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + RestResponse copyRes = null; + RestResponse getResource = null; + ResourceReqDetails resourceDetails = null; + RestResponse updateResource = null; + RestResponse createResource = null; + Resource resource = null; + RestResponse changeResourceState = null; + + // create new resource from Csar + copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_a.csar", "valid_vf.csar"); + resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("valid_vf.csar"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + String invariantUUID = resource.getInvariantUUID(); + + changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // change composition and update resource + copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_b.csar", "valid_vf.csar"); + BaseRestUtils.checkSuccess(copyRes); + // change name + resourceDetails.setName("test1"); + updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId()); + BaseRestUtils.checkSuccess(updateResource); + resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class); + assertEquals(2, resource.getComponentInstances().size()); + assertEquals(invariantUUID, resource.getInvariantUUID()); + + changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // back original scar + copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_a.csar", "valid_vf.csar"); + BaseRestUtils.checkSuccess(copyRes); + + // change name + resourceDetails.setName("test2"); + // change resource metaData and update resource + resourceDetails.setDescription("It is new description bla bla bla"); + updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId()); + BaseRestUtils.checkSuccess(updateResource); + resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + assertEquals(invariantUUID, resource.getInvariantUUID()); + + changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // back original scar + copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_a.csar", "valid_vf.csar"); + BaseRestUtils.checkSuccess(copyRes); + + // try to update resource with wrong RI (without node types, resource + // shouldn't be updated) + copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_c.csar", "valid_vf.csar"); + BaseRestUtils.checkSuccess(copyRes); + // change name (temporary) + resourceDetails.setName("test3"); + updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId()); + BaseRestUtils.checkErrorResponse(updateResource, ActionStatus.INVALID_NODE_TEMPLATE, "Definitions/tosca_mock_vf.yaml", "nodejs", "tosca.nodes.Weber"); + + getResource = ResourceRestUtils.getResourceByNameAndVersion(sdncModifierDetails.getUserId(), "test3", resourceDetails.getVersion()); + BaseRestUtils.checkErrorResponse(getResource, ActionStatus.RESOURCE_NOT_FOUND, "test3"); + getResource = ResourceRestUtils.getResourceByNameAndVersion(sdncModifierDetails.getUserId(), "test2", resourceDetails.getVersion()); + BaseRestUtils.checkSuccess(getResource); + + // back original scar + copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_a.csar", "valid_vf.csar"); + BaseRestUtils.checkSuccess(copyRes); + + // create new resource from Csar + // back original scar + copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar"); + BaseRestUtils.checkSuccess(copyRes); + + resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setName("TEST01"); + resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + + changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // scar with wrong RI + copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_b.csar", "VF_RI2_G4_withArtifacts.csar"); + BaseRestUtils.checkSuccess(copyRes); + resourceDetails.setDescription("BLA BLA BLA"); + // wrong RI (with node types) resource shouldn't be created + updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId()); + BaseRestUtils.checkErrorResponse(updateResource, ActionStatus.INVALID_NODE_TEMPLATE, "Definitions/VF_RI2_G1.yaml", "ps04_port_0", "org.openecomp.resource.cp.nodes.heat.network.neutron.Portur"); + // back original scar + copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar"); + BaseRestUtils.checkSuccess(copyRes); + } + + @Test(enabled = true) + public void createUpdateImportResourceFromCsarWithArtifactsTest() throws Exception { + User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + RestResponse copyRes = null; + ResourceReqDetails resourceDetails = null; + RestResponse updateResource = null; + RestResponse createResource = null; + Resource resource = null; + RestResponse changeResourceState = null; + + // back original scar + copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar"); + BaseRestUtils.checkSuccess(copyRes); + + resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setName("TEST01"); + resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar"); + resourceDetails.setCsarVersion("1"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + // create new resource from Csar + createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + + List<String> requiredArtifactsOld = resource.getDeploymentArtifacts().get("heat5").getRequiredArtifacts(); + assertTrue(requiredArtifactsOld != null && !requiredArtifactsOld.isEmpty() && requiredArtifactsOld.size() == 3); + assertTrue(requiredArtifactsOld.contains("hot-nimbus-pcm-volumes_v1.0.yaml")); + assertTrue(requiredArtifactsOld.contains("nested-pcm_v1.0.yaml")); + assertTrue(requiredArtifactsOld.contains("hot-nimbus-oam-volumes_v1.0.yaml")); + + // update scar with new artifacts + copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_updated.csar", "VF_RI2_G4_withArtifacts.csar"); + BaseRestUtils.checkSuccess(copyRes); + resourceDetails.setDescription("BLA BLA BLA"); + resourceDetails.setCsarVersion("2"); + updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId()); + BaseRestUtils.checkSuccess(updateResource); + resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class); + + List<String> requiredArtifactsNew = resource.getDeploymentArtifacts().get("heat5").getRequiredArtifacts(); + assertTrue(requiredArtifactsNew != null && !requiredArtifactsNew.isEmpty() && requiredArtifactsNew.size() == 3); + assertTrue(requiredArtifactsNew.contains("hot-nimbus-swift-container_v1.0.yaml")); + assertTrue(requiredArtifactsNew.contains("hot-nimbus-oam-volumes_v1.0.yaml")); + assertTrue(requiredArtifactsNew.contains("nested-oam_v1.0.yaml")); + + // back original scar + copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar"); + BaseRestUtils.checkSuccess(copyRes); + } + + @Test(enabled = true) + public void createUpdateImportWithPropertiesFromCsarUITest() throws Exception { + User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + String payloadName = "valid_vf.csar"; + ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource(); + String rootPath = System.getProperty("user.dir"); + Path path = null; + byte[] data = null; + String payloadData = null; + + path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + + // create new resource from Csar + resourceDetails.setCsarUUID(payloadName); + resourceDetails.setPayloadName(payloadName); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + + RestResponse changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // change composition (add new RI with specified property values) + path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf_d.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + // change name + resourceDetails.setName("test1"); + createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(6, resource.getComponentInstances().size()); + + changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + // change composition (add new specified property values to existing RI) + path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf_f.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + // change name + resourceDetails.setName("test2"); + createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(6, resource.getComponentInstances().size()); + + } + + public static RestResponse copyCsarRest(User sdncModifierDetails, String sourceCsarUuid, String targetCsarUuid) throws Exception { + + Config config = Utils.getConfig(); + String url = String.format(Urls.COPY_CSAR_USING_SIMULATOR, config.getCatalogBeHost(), config.getCatalogBePort(), sourceCsarUuid, targetCsarUuid); + String userId = sdncModifierDetails.getUserId(); + Map<String, String> headersMap = prepareHeadersMap(userId); + HttpRequest http = new HttpRequest(); + + RestResponse copyCsarResponse = http.httpSendPost(url, "dummy", headersMap); + if (copyCsarResponse.getErrorCode() != 200) { + return null; + } + return copyCsarResponse; + + } + + public static RestResponse getCsarRest(User sdncModifierDetails, String sourceCsarUuid) throws Exception { + + Config config = Utils.getConfig(); + String url = String.format(Urls.GET_CSAR_USING_SIMULATOR, config.getCatalogBeHost(), config.getCatalogBePort(), sourceCsarUuid); + String userId = sdncModifierDetails.getUserId(); + Map<String, String> headersMap = prepareHeadersMap(userId); + HttpRequest http = new HttpRequest(); + + RestResponse copyCsarResponse = http.httpSendGet(url, headersMap); + if (copyCsarResponse.getErrorCode() != 200) { + return null; + } + return copyCsarResponse; + + } + + @Test(enabled = true) + public void updateResourceFromCsarHappy() throws Exception { + RestResponse copyRes = copyCsarRest(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), "valid_vf_a.csar", "valid_vf.csar"); + BaseRestUtils.checkSuccess(copyRes); + // create + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("valid_vf"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + + String expectedCsarUUID = resourceDetails.getCsarUUID(); + String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase()); + + assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, resource.getCsarUUID()), expectedCsarUUID.equals(resource.getCsarUUID())); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName())); + + RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId()); + Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class); + assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, getResource.getCsarUUID()), expectedCsarUUID.equals(getResource.getCsarUUID())); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName())); + + RestResponse updateResource = ResourceRestUtils.updateResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), resourceDetails.getUniqueId()); + BaseRestUtils.checkSuccess(updateResource); + + } + + @Test(enabled = true) + public void createResourceFromCsarWithGroupsHappy() throws Exception { + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("csarWithGroups"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + + assertEquals("verify there are 2 groups", 2, resource.getGroups().size()); + + Map<String, String> compNameToUniqueId = resource.getComponentInstances().stream().collect(Collectors.toMap(p -> p.getName(), p -> p.getUniqueId())); + + // Verify 2 members on group1 + // members: [ app_server, mongo_server ] + String[] membersNameGroup1 = { "app_server", "mongo_server" }; + verifyMembersInResource(resource, compNameToUniqueId, "group1", membersNameGroup1); + // Verify 4 members on group2 + // members: [ mongo_db, nodejs, app_server, mongo_server ] + String[] membersNameGroup2 = { "app_server", "mongo_server", "mongo_db", "nodejs" }; + verifyMembersInResource(resource, compNameToUniqueId, "group2", membersNameGroup2); + + // Check OUT + resourceDetails.setUniqueId(resource.getUniqueId()); + RestResponse changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CHECKIN); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CHECKOUT); + assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue()); + + Resource checkedOutResource = ResponseParser.parseToObjectUsingMapper(changeResourceState.getResponse(), Resource.class); + compNameToUniqueId = checkedOutResource.getComponentInstances().stream().collect(Collectors.toMap(p -> p.getName(), p -> p.getUniqueId())); + + // Verify 2 members on group1 + // members: [ app_server, mongo_server ] + verifyMembersInResource(checkedOutResource, compNameToUniqueId, "group1", membersNameGroup1); + // Verify 4 members on group2 + // members: [ mongo_db, nodejs, app_server, mongo_server ] + verifyMembersInResource(checkedOutResource, compNameToUniqueId, "group2", membersNameGroup2); + + } + + private void verifyMembersInResource(Resource resource, Map<String, String> compNameToUniqueId, String groupName, String[] membersName) { + GroupDefinition groupDefinition = resource.getGroups().stream().filter(p -> p.getName().equals(groupName)).findFirst().get(); + assertEquals("Verify number of members", membersName.length, groupDefinition.getMembers().size()); + Map<String, String> createdMembers = groupDefinition.getMembers(); + Arrays.asList(membersName).forEach(p -> { + assertTrue("check member name exist", createdMembers.containsKey(p)); + }); + + verifyMembers(createdMembers, compNameToUniqueId); + } + + @Test(enabled = true) + public void createResourceFromCsarWithGroupsAndPropertiesHappy() throws Exception { + + RestResponse importNewGroupTypeByName = ImportRestUtils.importNewGroupTypeByName("myHeatStack1", UserRoleEnum.ADMIN); + // BaseRestUtils.checkCreateResponse(importNewGroupTypeByName); + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("csarWithGroupsWithProps"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + + assertEquals("verify there are 2 groups", 2, resource.getGroups().size()); + + Map<String, String> compNameToUniqueId = resource.getComponentInstances().stream().collect(Collectors.toMap(p -> p.getName(), p -> p.getUniqueId())); + + // Verify 2 members on group1 + // members: [ app_server, mongo_server ] + List<GroupDefinition> groupDefinition1 = resource.getGroups().stream().filter(p -> p.getName().equals("group1")).collect(Collectors.toList()); + assertEquals("Verify number of members", 2, groupDefinition1.get(0).getMembers().size()); + Map<String, String> createdMembers = groupDefinition1.get(0).getMembers(); + verifyMembers(createdMembers, compNameToUniqueId); + + List<PropertyDataDefinition> properties = groupDefinition1.get(0).getProperties(); + assertEquals("Verify number of members", 2, properties.size()); + + PropertyDataDefinition heatFiles = properties.stream().filter(p -> p.getName().equals("heat_files")).findFirst().get(); + assertNotNull("check heat files not empty", heatFiles); + List<String> heatFilesValue = new ArrayList<>(); + heatFilesValue.add("heat1.yaml"); + heatFilesValue.add("heat2.yaml"); + String heatFilesJson = gson.toJson(heatFilesValue); + log.debug(heatFiles.getValue()); + assertEquals("check heat files value", heatFilesJson, heatFiles.getValue()); + + PropertyDataDefinition urlCredential = properties.stream().filter(p -> p.getName().equals("url_credential")).findFirst().get(); + assertNotNull("check heat files not empty", urlCredential); + log.debug(urlCredential.getValue()); + assertEquals("check url credential", "{\"protocol\":\"protocol1\",\"keys\":{\"keya\":\"valuea\",\"keyb\":\"valueb\"}}", urlCredential.getValue()); + } + + @Test(enabled = true) + public void createResourceFromCsarWithGroupsAndPropertyInvalidValue() throws Exception { + + RestResponse importNewGroupTypeByName = ImportRestUtils.importNewGroupTypeByName("myHeatStack1", UserRoleEnum.ADMIN); + // BaseRestUtils.checkCreateResponse(importNewGroupTypeByName); + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("csarWithGroupsInvalidPropertyValue"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + + BaseRestUtils.checkStatusCode(createResource, "Check bad request error", false, 400); + + } + + @Test(enabled = true) + public void createResourceFromCsarWithGroupsAndInvalidPropertyName() throws Exception { + + RestResponse importNewGroupTypeByName = ImportRestUtils.importNewGroupTypeByName("myHeatStack1", UserRoleEnum.ADMIN); + // BaseRestUtils.checkCreateResponse(importNewGroupTypeByName); + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("csarWithGroupsPropertyNotExist"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + + BaseRestUtils.checkStatusCode(createResource, "Check bad request error", false, 400); + BaseRestUtils.checkErrorResponse(createResource, ActionStatus.GROUP_PROPERTY_NOT_FOUND, "url_credential111", "group1", "org.openecomp.groups.MyHeatStack1"); + + } + + @Test(enabled = true) + public void createResourceFromCsarGroupTypeNotExist() throws Exception { + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("csarWithGroupsInvalidGroupType"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + + BaseRestUtils.checkStatusCode(createResource, "Check bad request error", false, 400); + BaseRestUtils.checkErrorResponse(createResource, ActionStatus.GROUP_TYPE_IS_INVALID, "org.openecomp.groups.stamGroupType"); + + } + + @Test(enabled = true) + public void createResourceFromCsarMemberNotExist() throws Exception { + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("csarWithGroupsInvalidMember"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + + BaseRestUtils.checkStatusCode(createResource, "Check bad request error", false, 400); + BaseRestUtils.checkErrorResponse(createResource, ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, "mycomp", "mygroup", ValidationUtils.normaliseComponentName(resourceDetails.getName()), "VF"); + + } + + @Test(enabled = true) + public void createResourceFromCsarMemberNotAllowed() throws Exception { + + RestResponse importNewGroupTypeByName = ImportRestUtils.importNewGroupTypeByName("myHeatStack2", UserRoleEnum.ADMIN); + + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("csarWithGroupsNotAllowedMember"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + + BaseRestUtils.checkStatusCode(createResource, "Check bad request error", false, 400); + BaseRestUtils.checkErrorResponse(createResource, ActionStatus.GROUP_INVALID_TOSCA_NAME_OF_COMPONENT_INSTANCE, "nodejs", "group1", "org.openecomp.groups.MyHeatStack2"); + + } + + @Test(enabled = true) + public void getResourceFromCsarUuidHappy() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("tam"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(6, resource.getComponentInstances().size()); + + String expectedCsarUUID = resourceDetails.getCsarUUID(); + String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase()); + + assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, resource.getCsarUUID()), expectedCsarUUID.equals(resource.getCsarUUID())); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName())); + + RestResponse getResourceResponse = ResourceRestUtils.getLatestResourceFromCsarUuid(resource.getCsarUUID()); + Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class); + assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, getResource.getCsarUUID()), expectedCsarUUID.equals(getResource.getCsarUUID())); + assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName())); + } + + @Test(enabled = true) + public void getResourceFromCsarResourceNotFound() throws Exception { + String csarUUID = "tam"; + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID(csarUUID); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + + RestResponse resResponse = ResourceRestUtils.getLatestResourceFromCsarUuid(csarUUID); + + BaseRestUtils.checkStatusCode(resResponse, "Check bad request error", false, 400); + BaseRestUtils.checkErrorResponse(resResponse, ActionStatus.RESOURCE_FROM_CSAR_NOT_FOUND, csarUUID); + + } + + @Test(enabled = true) + public void getResourceFromMissingCsar() throws Exception { + String csarUUID = "abcdefg12345"; + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID(csarUUID); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + + RestResponse resResponse = ResourceRestUtils.getLatestResourceFromCsarUuid(csarUUID); + + BaseRestUtils.checkStatusCode(resResponse, "Check bad request error", false, 400); + BaseRestUtils.checkErrorResponse(resResponse, ActionStatus.RESOURCE_FROM_CSAR_NOT_FOUND, csarUUID); + + } + + @Test(enabled = true) + public void createUpdateCertifiedImportResourceFromCsarTest() throws Exception { + User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + RestResponse copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_a.csar", "valid_vf.csar"); + RestResponse updateResponse = null; + String oldName = null; + // create new resource from Csar + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("valid_vf.csar"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + String invariantUUID = resource.getInvariantUUID(); + + // change metadata + // resource name, icon, vendor name, category, template derivedFrom + oldName = resourceDetails.getName(); + resourceDetails.setName("test1"); + resourceDetails.setIcon("newicon"); + resourceDetails.setVendorName("newname"); + createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkErrorResponse(createResource, ActionStatus.VSP_ALREADY_EXISTS, "valid_vf.csar", oldName); + + updateResponse = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId()); + BaseRestUtils.checkSuccess(updateResponse); + + LifecycleRestUtils.certifyResource(resourceDetails); + // change metadata + // resource name, icon, vendor name, category, template derivedFrom + resourceDetails.setName("test2"); + resourceDetails.setIcon("new icon1"); + resourceDetails.setVendorName("new name1"); + resourceDetails.setDescription("bla bla bla"); + updateResponse = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId()); + BaseRestUtils.checkSuccess(updateResponse); + resource = ResponseParser.parseToObjectUsingMapper(updateResponse.getResponse(), Resource.class); + assertEquals(5, resource.getComponentInstances().size()); + assertEquals(invariantUUID, resource.getInvariantUUID()); + assertEquals(resource.getName(), "test1"); + assertEquals(resource.getIcon(), "newicon"); + assertEquals(resource.getVendorName(), "newname"); + assertEquals(resource.getDescription(), "bla bla bla"); + assertEquals(resource.getTags().contains("test2"), false); + } + + @Test + public void createImportRIRelationByCapNameFromCsarUITest() throws Exception { + User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + String payloadName = "vmmc_relate_by_cap_name.csar"; + ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource(); + String rootPath = System.getProperty("user.dir"); + Path path = null; + byte[] data = null; + String payloadData = null; + + path = Paths.get(rootPath + "/src/test/resources/CI/csars/vmmc_relate_by_cap_name.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + + // create new resource from Csar + resourceDetails.setCsarUUID(payloadName); + resourceDetails.setPayloadName(payloadName); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + // assert all relations created + assertEquals(80, resource.getComponentInstancesRelations().size()); + } + + @Test + public void createImportRIRelationByCapNameFromCsarUITest2() throws Exception { + User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + String payloadName = "vf_relate_by_cap_name.csar"; + ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource(); + String rootPath = System.getProperty("user.dir"); + Path path = null; + byte[] data = null; + String payloadData = null; + + path = Paths.get(rootPath + "/src/test/resources/CI/csars/vf_relate_by_cap_name.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + + // create new resource from Csar + resourceDetails.setCsarUUID(payloadName); + resourceDetails.setPayloadName(payloadName); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + // assert relations created: 1.by name: virtual_linkable. 2.by name: + // link + Map<String, ComponentInstance> nodes = resource.getComponentInstances().stream().collect(Collectors.toMap(n -> n.getName(), n -> n)); + Map<String, CapabilityDefinition> capabilities = nodes.get("elinenode").getCapabilities().get("tosca.capabilities.network.Linkable").stream().collect(Collectors.toMap(e -> e.getName(), e -> e)); + String cp1Uid = nodes.get("cp1node").getUniqueId(); + String cp2Uid = nodes.get("cp2node").getUniqueId(); + Map<String, List<RequirementCapabilityRelDef>> mappedByReqOwner = resource.getComponentInstancesRelations().stream().collect(Collectors.groupingBy(e -> e.getFromNode())); + assertEquals(mappedByReqOwner.get(cp1Uid).get(0).getRelationships().get(0).getCapabilityUid(), capabilities.get("virtual_linkable").getUniqueId()); + assertEquals(mappedByReqOwner.get(cp2Uid).get(0).getRelationships().get(0).getCapabilityUid(), capabilities.get("link").getUniqueId()); + } + + @Test(enabled = true) + public void importCsarCheckVfHeatEnv() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("csar_1"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + + + Map<String, ArtifactDefinition> deploymentArtifacts = resource.getDeploymentArtifacts(); + assertNotNull(deploymentArtifacts); + // 2 lisence, 1 heat, 1 heatenv + assertEquals(4, deploymentArtifacts.size()); + + ArtifactDefinition artifactHeat = deploymentArtifacts.get("heat0"); + assertNotNull(artifactHeat); + + ArtifactDefinition artifactHeatEnv = deploymentArtifacts.get("heat0env"); + assertNotNull(artifactHeatEnv); + + assertEquals(artifactHeat.getUniqueId(), artifactHeatEnv.getGeneratedFromId()); + assertEquals("VF HEAT ENV", artifactHeatEnv.getArtifactDisplayName()); + assertEquals("HEAT_ENV", artifactHeatEnv.getArtifactType()); + assertEquals("VF Auto-generated HEAT Environment deployment artifact", artifactHeatEnv.getDescription()); + + String designerUserId = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER).getUserId(); + String testerUserId = ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getUserId(); + RestResponse lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKIN); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKOUT); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKIN); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CERTIFICATIONREQUEST); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUserId, LifeCycleStatesEnum.STARTCERTIFICATION); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUserId, LifeCycleStatesEnum.CERTIFY); + LifecycleRestUtils.checkSuccess(lifecycleChangeResponse); + Resource certifiedResource = ResponseParser.parseToObjectUsingMapper(lifecycleChangeResponse.getResponse(), Resource.class); + + + User modifier = new User(); + modifier.setUserId(designerUserId); + + ServiceReqDetails serviceDetails = ElementFactory.getDefaultService("newtestservice1", ServiceCategoriesEnum.MOBILITY, designerUserId); + + RestResponse serviceRes = ServiceRestUtils.createService(serviceDetails, modifier); + ResourceRestUtils.checkCreateResponse(serviceRes); + Service service = ResponseParser.parseToObjectUsingMapper(serviceRes.getResponse(), Service.class); + + ComponentInstanceReqDetails resourceInstanceReqDetails = ElementFactory.getComponentInstance(certifiedResource); + RestResponse createResourceInstanceResponse = ComponentInstanceRestUtils.createComponentInstance(resourceInstanceReqDetails, modifier, service.getUniqueId(), service.getComponentType()); + BaseRestUtils.checkCreateResponse(createResourceInstanceResponse); + RestResponse serviceByGet = ServiceRestUtils.getService(service.getUniqueId()); + service = ResponseParser.parseToObjectUsingMapper(serviceByGet.getResponse(), Service.class); + + List<ComponentInstance> componentInstances = service.getComponentInstances(); + assertNotNull(componentInstances); + + assertEquals(1, componentInstances.size()); + ComponentInstance ci = componentInstances.get(0); + Map<String, ArtifactDefinition> instDepArtifacts = ci.getDeploymentArtifacts(); + assertNotNull(instDepArtifacts); + ArtifactDefinition instArtifactHeat = instDepArtifacts.get("heat0"); + assertNotNull(instArtifactHeat); + + ArtifactDefinition instArtifactHeatEnv = instDepArtifacts.get("heat0env"); + assertNotNull(instArtifactHeatEnv); + assertEquals(artifactHeat.getUniqueId(), instArtifactHeatEnv.getGeneratedFromId()); + assertEquals("HEAT ENV", instArtifactHeatEnv.getArtifactDisplayName()); + assertEquals("HEAT_ENV", instArtifactHeatEnv.getArtifactType()); + + assertEquals(artifactHeat.getUniqueId(), instArtifactHeat.getUniqueId()); + //different artifacts + assertTrue( !artifactHeatEnv.getUniqueId().equals(instArtifactHeat.getUniqueId()) ); + + + } + + @Test(enabled = true) + public void createAndUpdateCsarCheckVfHeatEnv() throws Exception { + ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(); + resourceDetails.setCsarUUID("orig2G_org"); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + + + Map<String, ArtifactDefinition> deploymentArtifacts = resource.getDeploymentArtifacts(); + assertNotNull(deploymentArtifacts); + + assertEquals(13, deploymentArtifacts.size()); + + ArtifactDefinition artifactHeat = deploymentArtifacts.get("heat0"); + assertNotNull(artifactHeat); + + ArtifactDefinition artifactHeatEnv = deploymentArtifacts.get("heat0env"); + assertNotNull(artifactHeatEnv); + + assertEquals(artifactHeat.getUniqueId(), artifactHeatEnv.getGeneratedFromId()); + assertEquals("VF HEAT ENV", artifactHeatEnv.getArtifactDisplayName()); + assertEquals("HEAT_ENV", artifactHeatEnv.getArtifactType()); + assertEquals("VF Auto-generated HEAT Environment deployment artifact", artifactHeatEnv.getDescription()); + + List<GroupDefinition> groups = resource.getGroups(); + assertEquals(2, groups.size()); + GroupDefinition group1 = groups.stream().filter(p -> p.getName().contains("module-0")).findAny().get(); + GroupDefinition group2 = groups.stream().filter(p -> p.getName().contains("module-1")).findAny().get(); + assertEquals(11, group1.getArtifacts().size()); + assertEquals(3, group2.getArtifacts().size()); + + resourceDetails.setCsarUUID("orig2G_update"); + + RestResponse updateResource = ResourceRestUtils.updateResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), resourceDetails.getUniqueId()); + BaseRestUtils.checkSuccess(updateResource); + + resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class); + + + Map<String, ArtifactDefinition> deploymentArtifactsUpd = resource.getDeploymentArtifacts(); + assertNotNull(deploymentArtifactsUpd); + + assertEquals(13, deploymentArtifactsUpd.size()); + + ArtifactDefinition artifactHeatUpd = deploymentArtifacts.get("heat0"); + assertNotNull(artifactHeatUpd); + + ArtifactDefinition artifactHeatEnvUpd = deploymentArtifacts.get("heat0env"); + assertNotNull(artifactHeatEnvUpd); + + groups = resource.getGroups(); + assertEquals(2, groups.size()); + assertEquals(7, groups.get(0).getArtifacts().size()); + assertEquals(7, groups.get(1).getArtifacts().size()); + + + } + + @Test + public void importInnerVfcWithArtifactsSucceed() throws Exception { + User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); + String rootPath = System.getProperty("user.dir"); + ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource(); + + String payloadName = "ImportArtifactsToVFC.csar"; + Path path = Paths.get(rootPath + "/src/test/resources/CI/csars/ImportArtifactsToVFC.csar"); + byte[] data = Files.readAllBytes(path); + String payloadData = Base64.encodeBase64String(data); + resourceDetails.setPayloadData(payloadData); + resourceDetails.setPayloadName(payloadName); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + + RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + + List<ComponentInstance> componentInstances = resource.getComponentInstances(); + List<ComponentInstance> reducedComponentInstances = componentInstances.stream() + .filter(ci->ci.getNormalizedName().contains("server_sm")) + .collect(Collectors.toList()); + assertTrue(!reducedComponentInstances.isEmpty() && reducedComponentInstances.size() == 2); + reducedComponentInstances.stream().forEach(ci->isValidArtifacts(ci)); + + payloadName = "ImportArtifactsToVFC_empty.csar"; + path = Paths.get(rootPath + "/src/test/resources/CI/csars/ImportArtifactsToVFC_empty.csar"); + data = Files.readAllBytes(path); + payloadData = Base64.encodeBase64String(data); + resourceDetails.setName(resourceDetails.getName()+"2"); + resourceDetails.setPayloadData(payloadData); + resourceDetails.setPayloadName(payloadName); + resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); + + createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); + BaseRestUtils.checkCreateResponse(createResource); + resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); + + componentInstances = resource.getComponentInstances(); + reducedComponentInstances = componentInstances.stream() + .filter(ci->ci.getNormalizedName().contains("server_sm")) + .collect(Collectors.toList()); + assertTrue(!reducedComponentInstances.isEmpty() && reducedComponentInstances.size() == 2); + reducedComponentInstances.stream() + .forEach(ci->assertTrue( + (ci.getDeploymentArtifacts()==null || ci.getDeploymentArtifacts().isEmpty()) && + (ci.getArtifacts()==null || ci.getArtifacts().isEmpty())) + ); + } + + private void isValidArtifacts(ComponentInstance ci) { + assertTrue(!ci.getDeploymentArtifacts().isEmpty() && ci.getDeploymentArtifacts().size() == 11); + ci.getDeploymentArtifacts().values().stream() + .forEach(a->assertTrue(a.getArtifactName().startsWith("Some"))); + + assertTrue(!ci.getArtifacts().isEmpty() && ci.getArtifacts().size() == 1); + ci.getArtifacts().values().stream() + .forEach(a->assertTrue(a.getArtifactName().startsWith("Process"))); + } + + private void verifyMembers(Map<String, String> createdMembers, Map<String, String> compNameToUniqueId) { + for (Map.Entry<String, String> entry : createdMembers.entrySet()) { + String key = entry.getKey(); + String value = entry.getValue(); + String comparedValue = compNameToUniqueId.get(key); + + assertEquals("compare instance ids", comparedValue, value); + } + + } + + private static Map<String, String> prepareHeadersMap(String userId) { + Map<String, String> headersMap = new HashMap<String, String>(); + headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), "application/json"); + headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), "application/json"); + if (userId != null) { + headersMap.put(HttpHeaderEnum.USER_ID.getValue(), userId); + } + return headersMap; + } + +} |