asdc-tests/src/main/java/org/openecomp/sdc/ci/tests/execute/imports/ImportCsarResourceTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.execute.imports;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertNotNull;
  25 import static org.testng.AssertJUnit.assertTrue;
  26
  27 import java.nio.file.Files;
  28 import java.nio.file.Path;
  29 import java.nio.file.Paths;
  30 import java.util.ArrayList;
  31 import java.util.Arrays;
  32 import java.util.Collection;
  33 import java.util.HashMap;
  34 import java.util.Iterator;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.Set;
  38 import java.util.stream.Collectors;
  39
  40 import org.apache.commons.codec.binary.Base64;
  41 import org.apache.commons.lang.WordUtils;
  42 import org.junit.Rule;
  43 import org.junit.rules.TestName;
  44 import org.openecomp.sdc.be.dao.api.ActionStatus;
  45 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  46 import org.openecomp.sdc.be.model.ArtifactDefinition;
  47 import org.openecomp.sdc.be.model.CapabilityDefinition;
  48 import org.openecomp.sdc.be.model.ComponentInstance;
  49 import org.openecomp.sdc.be.model.GroupDefinition;
  50 import org.openecomp.sdc.be.model.GroupProperty;
  51 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  52 import org.openecomp.sdc.be.model.Resource;
  53 import org.openecomp.sdc.be.model.Service;
  54 import org.openecomp.sdc.be.model.User;
  55 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  56 import org.openecomp.sdc.ci.tests.api.Urls;
  57 import org.openecomp.sdc.ci.tests.config.Config;
  58 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  59 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
  60 import org.openecomp.sdc.ci.tests.datatypes.ImportReqDetails;
  61 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  62 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  63 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  64 import org.openecomp.sdc.ci.tests.datatypes.enums.ServiceCategoriesEnum;
  65 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  66 import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum;
  67 import org.openecomp.sdc.ci.tests.datatypes.http.HttpRequest;
  68 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  69 import org.openecomp.sdc.ci.tests.utils.Utils;
  70 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  71 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
  72 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  73 import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils;
  74 import org.openecomp.sdc.ci.tests.utils.rest.GroupRestUtils;
  75 import org.openecomp.sdc.ci.tests.utils.rest.ImportRestUtils;
  76 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  77 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  78 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  79 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  80 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  81 import org.openecomp.sdc.common.util.ValidationUtils;
  82 import org.slf4j.Logger;
  83 import org.slf4j.LoggerFactory;
  84 import org.testng.annotations.Test;
  85
  86 import com.google.gson.Gson;
  87
  88 public class ImportCsarResourceTest extends ComponentBaseTest {
  89         private static Logger log = LoggerFactory.getLogger(ImportCsarResourceTest.class.getName());
  90         @Rule
  91         public static TestName name = new TestName();
  92         private static final String CSARS_PATH = "/src/test/resources/CI/csars/";
  93         Gson gson = new Gson();
  94
  95         public ImportCsarResourceTest() {
  96                 super(name, ImportCsarResourceTest.class.getName());
  97         }
  98
  99         private String buildAssertMessage(String expectedString, String actualString) {
 100                 return String.format("expected is : %s , actual is: %s", expectedString, actualString);
 101         }
 102
 103         /**
 104          *
 105          * User Story : US640615 [BE] - Extend create VF API with Import TOSCA CSAR
 106          */
 107
 108         @Test(enabled = true)
 109         public void createResourceFromCsarHappy() throws Exception {
 110                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 111                 resourceDetails.setCsarUUID("AF7F231969C5463F9C968570070E8877");
 112                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 113                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 114                 BaseRestUtils.checkCreateResponse(createResource);
 115                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 116                 assertEquals(5, resource.getComponentInstances().size());
 117
 118                 String expectedCsarUUID = resourceDetails.getCsarUUID();
 119                 String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase());
 120
 121                 assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, resource.getCsarUUID()), expectedCsarUUID.equals(resource.getCsarUUID()));
 122                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName()));
 123
 124                 RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId());
 125                 Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class);
 126                 assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, getResource.getCsarUUID()), expectedCsarUUID.equals(getResource.getCsarUUID()));
 127                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName()));
 128         }
 129
 130         @Test(enabled = true)
 131         public void emptyStringInCsarUUIDFieldTest() throws Exception {
 132                 String emptyString = "";
 133                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 134                 resourceDetails.setCsarUUID(emptyString);
 135                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 136                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 137                 BaseRestUtils.checkCreateResponse(createResource);
 138                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 139                 assertEquals(null, resource.getComponentInstances());
 140
 141                 String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase());
 142
 143                 assertTrue("csarUUID : " + buildAssertMessage(emptyString, resource.getCsarUUID()), resource.getCsarUUID() == emptyString);
 144                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName()));
 145
 146                 RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId());
 147                 Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class);
 148                 assertTrue("csarUUID : " + buildAssertMessage(emptyString, getResource.getCsarUUID()), getResource.getCsarUUID() == emptyString);
 149                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName()));
 150         }
 151
 152         @Test(enabled = true)
 153         public void createResourceFromScratchTest() throws Exception {
 154                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 155                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 156                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 157                 BaseRestUtils.checkCreateResponse(createResource);
 158                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 159                 assertEquals(null, resource.getComponentInstances());
 160
 161                 String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase());
 162
 163                 assertTrue("csarUUID : " + buildAssertMessage(null, resource.getCsarUUID()), resource.getCsarUUID() == null);
 164                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName()));
 165
 166                 RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId());
 167                 Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class);
 168                 assertTrue("csarUUID : " + buildAssertMessage(null, getResource.getCsarUUID()), getResource.getCsarUUID() == null);
 169                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName()));
 170         }
 171
 172         @Test(enabled = true)
 173         public void fileNotCsarTypeTest() throws Exception {
 174                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 175                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 176                 resourceDetails.setCsarUUID("valid_vf_zip");
 177                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 178                 List<String> variables = new ArrayList<String>();
 179                 variables.add(resourceDetails.getCsarUUID());
 180                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_NOT_FOUND.name(), variables, createResource.getResponse());
 181         }
 182
 183         @Test(enabled = true)
 184         public void missingToscaMetadataFolderTest() throws Exception {
 185
 186                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 187                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 188                 resourceDetails.setCsarUUID("toscaFolderNotExists");
 189                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 190                 List<String> variables = new ArrayList<String>();
 191                 variables.add(resourceDetails.getCsarUUID());
 192                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID.name(), variables, createResource.getResponse());
 193         }
 194
 195         @Test(enabled = true)
 196         public void missingToscaMetaFileTest() throws Exception {
 197
 198                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 199                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 200                 resourceDetails.setCsarUUID("toscaMetaFileNotExists");
 201                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 202                 List<String> variables = new ArrayList<String>();
 203                 variables.add(resourceDetails.getCsarUUID());
 204                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID.name(), variables, createResource.getResponse());
 205         }
 206
 207         @Test(enabled = true)
 208         public void toscaMetaFileOutsideTheFolderTest() throws Exception {
 209
 210                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 211                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 212                 resourceDetails.setCsarUUID("toscaMetaOutsideTheFolder");
 213                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 214                 List<String> variables = new ArrayList<String>();
 215                 variables.add(resourceDetails.getCsarUUID());
 216                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID.name(), variables, createResource.getResponse());
 217         }
 218
 219         @Test(enabled = true)
 220         public void caseSensitiveTest_1() throws Exception {
 221
 222                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 223                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 224                 resourceDetails.setCsarUUID("caseSensitiveTest_1");
 225                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 226                 List<String> variables = new ArrayList<String>();
 227                 variables.add(resourceDetails.getCsarUUID());
 228                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID.name(), variables, createResource.getResponse());
 229         }
 230
 231         @Test(enabled = true)
 232         public void caseSensitiveTest_2() throws Exception {
 233
 234                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 235                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 236                 resourceDetails.setCsarUUID("caseSensitiveTest_2");
 237                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 238                 List<String> variables = new ArrayList<String>();
 239                 variables.add(resourceDetails.getCsarUUID());
 240                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID.name(), variables, createResource.getResponse());
 241         }
 242
 243         @Test(enabled = true)
 244         public void missingOneLineInToscaMetaFileTest() throws Exception {
 245
 246                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 247                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 248                 resourceDetails.setCsarUUID("missingOneLineInToscaMeta");
 249                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 250                 List<String> variables = new ArrayList<String>();
 251                 variables.add(resourceDetails.getCsarUUID());
 252                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 253         }
 254
 255         @Test(enabled = true)
 256         public void noCSARVersionTest() throws Exception {
 257                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 258                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 259                 resourceDetails.setCsarUUID("noCSARVersion");
 260                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 261                 List<String> variables = new ArrayList<String>();
 262                 variables.add(resourceDetails.getCsarUUID());
 263                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 264         }
 265
 266         @Test(enabled = true)
 267         public void noCreatedByValueTest() throws Exception {
 268                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 269                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 270                 resourceDetails.setCsarUUID("noCreatedByValue");
 271                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 272                 List<String> variables = new ArrayList<String>();
 273                 variables.add(resourceDetails.getCsarUUID());
 274                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 275         }
 276
 277         @Test(enabled = true)
 278         public void noEntryDefinitionsValueTest() throws Exception {
 279                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 280                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 281                 resourceDetails.setCsarUUID("noEntryDefinitionsValue");
 282                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 283                 List<String> variables = new ArrayList<String>();
 284                 variables.add(resourceDetails.getCsarUUID());
 285                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 286         }
 287
 288         @Test(enabled = true)
 289         public void noTOSCAMetaFileVersionValueTest() throws Exception {
 290                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 291                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 292                 resourceDetails.setCsarUUID("noTOSCAMetaFileVersionValue");
 293                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 294                 List<String> variables = new ArrayList<String>();
 295                 variables.add(resourceDetails.getCsarUUID());
 296                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 297         }
 298
 299         @Test(enabled = true)
 300         public void invalidCsarVersionInMetaFileTest() throws Exception {
 301                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 302                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 303                 resourceDetails.setCsarUUID("invalidCsarVersion");
 304                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 305                 List<String> variables = new ArrayList<String>();
 306                 variables.add(resourceDetails.getCsarUUID());
 307                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 308
 309                 resourceDetails.setCsarUUID("invalidCsarVersion2");
 310                 createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 311                 variables = new ArrayList<String>();
 312                 variables.add(resourceDetails.getCsarUUID());
 313                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 314
 315                 resourceDetails.setCsarUUID("invalidCsarVersion3");
 316                 createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 317                 variables = new ArrayList<String>();
 318                 variables.add(resourceDetails.getCsarUUID());
 319                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 320
 321                 resourceDetails.setCsarUUID("invalidCsarVersion4");
 322                 createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 323                 variables = new ArrayList<String>();
 324                 variables.add(resourceDetails.getCsarUUID());
 325                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 326
 327                 resourceDetails.setCsarUUID("invalidCsarVersion5");
 328                 createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 329                 variables = new ArrayList<String>();
 330                 variables.add(resourceDetails.getCsarUUID());
 331                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 332
 333         }
 334
 335         @Test(enabled = true)
 336         public void validCsarVersionInMetaFileTest() throws Exception {
 337                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 338                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 339                 resourceDetails.setCsarUUID("validCsarVersion");
 340                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 341                 BaseRestUtils.checkCreateResponse(createResource);
 342                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 343                 assertEquals(5, resource.getComponentInstances().size());
 344
 345                 String expectedCsarUUID = resourceDetails.getCsarUUID();
 346                 String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase());
 347
 348                 assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, resource.getCsarUUID()), expectedCsarUUID.equals(resource.getCsarUUID()));
 349                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName()));
 350
 351                 RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId());
 352                 Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class);
 353                 assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, getResource.getCsarUUID()), expectedCsarUUID.equals(getResource.getCsarUUID()));
 354                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName()));
 355         }
 356
 357         @Test(enabled = true)
 358         public void underscoreInToscaMetaFileVersionNameTest() throws Exception {
 359                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 360                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 361                 resourceDetails.setCsarUUID("underscoreInsteadOfDash");
 362                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 363                 List<String> variables = new ArrayList<String>();
 364                 variables.add(resourceDetails.getCsarUUID());
 365                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 366         }
 367
 368         @Test(enabled = true)
 369         public void missingEntryDefintionInMetaFileTest() throws Exception {
 370                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 371                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 372                 resourceDetails.setCsarUUID("missingEntryDefintionPair");
 373                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 374                 List<String> variables = new ArrayList<String>();
 375                 variables.add(resourceDetails.getCsarUUID());
 376                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 377         }
 378
 379         @Test(enabled = false)
 380         public void noNewLineAfterBLock0Test() throws Exception {
 381                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 382                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 383                 resourceDetails.setCsarUUID("noNewLineAfterBLock0");
 384                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 385                 List<String> variables = new ArrayList<String>();
 386                 variables.add(resourceDetails.getCsarUUID());
 387                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 388         }
 389
 390         @Test(enabled = true)
 391         public void moreThanOneYamlFileTest() throws Exception {
 392                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 393                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 394                 resourceDetails.setCsarUUID("moreThenOneYamlFile");
 395                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 396                 BaseRestUtils.checkCreateResponse(createResource);
 397                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 398                 assertEquals(5, resource.getComponentInstances().size());
 399
 400                 String expectedCsarUUID = resourceDetails.getCsarUUID();
 401                 String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase());
 402
 403                 assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, resource.getCsarUUID()), expectedCsarUUID.equals(resource.getCsarUUID()));
 404                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName()));
 405
 406                 RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId());
 407                 Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class);
 408                 assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, getResource.getCsarUUID()), expectedCsarUUID.equals(getResource.getCsarUUID()));
 409                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName()));
 410         }
 411
 412         @Test(enabled = true)
 413         public void moreThanOneMetaFileTest() throws Exception {
 414                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 415                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 416                 resourceDetails.setCsarUUID("moreThanOneMetaFile");
 417                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 418                 BaseRestUtils.checkCreateResponse(createResource);
 419                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 420                 assertEquals(5, resource.getComponentInstances().size());
 421
 422                 String expectedCsarUUID = resourceDetails.getCsarUUID();
 423                 String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase());
 424
 425                 assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, resource.getCsarUUID()), expectedCsarUUID.equals(resource.getCsarUUID()));
 426                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName()));
 427
 428                 RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId());
 429                 Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class);
 430                 assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, getResource.getCsarUUID()), expectedCsarUUID.equals(getResource.getCsarUUID()));
 431                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName()));
 432         }
 433
 434         @Test(enabled = true)
 435         public void csarNotContainsYamlAndMetaFilesTest() throws Exception {
 436
 437                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 438                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 439                 resourceDetails.setCsarUUID("notContainYamlAndMetaFiles");
 440                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 441                 List<String> variables = new ArrayList<String>();
 442                 variables.add(resourceDetails.getCsarUUID());
 443                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID.name(), variables, createResource.getResponse());
 444         }
 445
 446         @Test(enabled = true)
 447         public void csarNotContainsYamlFileTest() throws Exception {
 448
 449                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 450                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 451                 resourceDetails.setCsarUUID("notContainYamlFile");
 452                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 453                 List<String> variables = new ArrayList<String>();
 454                 variables.add(resourceDetails.getCsarUUID());
 455                 variables.add("Definitions/tosca_mock_vf.yaml");
 456                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.YAML_NOT_FOUND_IN_CSAR.name(), variables, createResource.getResponse());
 457         }
 458
 459         @Test(enabled = true)
 460         public void missingCsarFileTest() throws Exception {
 461
 462                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 463                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 464                 resourceDetails.setCsarUUID("abc");
 465                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 466                 List<String> variables = new ArrayList<String>();
 467                 variables.add(resourceDetails.getCsarUUID());
 468                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_NOT_FOUND.name(), variables, createResource.getResponse());
 469         }
 470
 471         @Test(enabled = true)
 472         public void longNamesInToscaMetaFileTest_1() throws Exception {
 473                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 474                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 475                 resourceDetails.setCsarUUID("longNamesInToscaMetaFile1");
 476                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 477                 List<String> variables = new ArrayList<String>();
 478                 variables.add(resourceDetails.getCsarUUID());
 479                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 480         }
 481
 482         @Test(enabled = true)
 483         public void longNamesInToscaMetaFileTest_2() throws Exception {
 484                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 485                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 486                 resourceDetails.setCsarUUID("longNamesInToscaMetaFile2");
 487                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 488                 List<String> variables = new ArrayList<String>();
 489                 variables.add(resourceDetails.getCsarUUID());
 490                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 491         }
 492
 493         @Test(enabled = true)
 494         public void longNamesInToscaMetaFileTest_3() throws Exception {
 495                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 496                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 497                 resourceDetails.setCsarUUID("longNamesInToscaMetaFile3");
 498                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 499                 List<String> variables = new ArrayList<String>();
 500                 variables.add(resourceDetails.getCsarUUID());
 501                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 502         }
 503
 504         @Test(enabled = true)
 505         public void longNamesInToscaMetaFileTest_4() throws Exception {
 506                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 507                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 508                 resourceDetails.setCsarUUID("longNamesInToscaMetaFile4");
 509                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 510                 List<String> variables = new ArrayList<String>();
 511                 variables.add(resourceDetails.getCsarUUID());
 512                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 513         }
 514
 515         @Test(enabled = true)
 516         public void longNamesInToscaMetaFileTest_5() throws Exception {
 517                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 518                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 519                 resourceDetails.setCsarUUID("longNamesInToscaMetaFile5");
 520                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 521                 List<String> variables = new ArrayList<String>();
 522                 variables.add(resourceDetails.getCsarUUID());
 523                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 524         }
 525
 526         // possible to have more than four lines in block 0
 527         // @Test (enabled = true)
 528         public void fiveLinesAsBlock0Test() throws Exception {
 529                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 530                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 531                 resourceDetails.setCsarUUID("fiveLinesAsBlock0");
 532                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 533                 List<String> variables = new ArrayList<String>();
 534                 variables.add(resourceDetails.getCsarUUID());
 535                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.CSAR_INVALID_FORMAT.name(), variables, createResource.getResponse());
 536         }
 537
 538         @Test(enabled = true)
 539         public void lifecycleChangingToResourceFromCsarTest() throws Exception {
 540                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 541                 resourceDetails.setCsarUUID("valid_vf");
 542                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 543                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 544                 BaseRestUtils.checkCreateResponse(createResource);
 545
 546                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 547                 assertTrue("0.1".equals(resource.getVersion()));
 548                 assertTrue(LifeCycleStatesEnum.CHECKOUT.getComponentState().equals(resource.getLifecycleState().toString()));
 549
 550                 String designerUserId = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER).getUserId();
 551                 String testerUserId = ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getUserId();
 552                 String csarUniqueId = resourceDetails.getUniqueId();
 553                 assertNotNull(csarUniqueId);
 554
 555                 RestResponse lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKIN);
 556                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
 557                 lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKOUT);
 558                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
 559                 lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKIN);
 560                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
 561                 lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 562                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
 563                 lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUserId, LifeCycleStatesEnum.STARTCERTIFICATION);
 564                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
 565                 lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUserId, LifeCycleStatesEnum.CERTIFY);
 566                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
 567                 lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKOUT);
 568                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
 569
 570                 resource = ResponseParser.parseToObjectUsingMapper(lifecycleChangeResponse.getResponse(), Resource.class);
 571                 Map<String, String> allVersions = resource.getAllVersions();
 572                 assertEquals(2, allVersions.keySet().size());
 573                 assertEquals(2, allVersions.values().size());
 574                 Set<String> keySet = allVersions.keySet();
 575                 assertTrue(keySet.contains("1.0"));
 576                 assertTrue(keySet.contains("1.1"));
 577         }
 578
 579         @Test(enabled = true)
 580         public void csarWithJsonPromEnvTest() throws Exception {
 581                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 582                 resourceDetails.setCsarUUID("VSPPackageJsonProp.csar");
 583                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 584                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 585                 BaseRestUtils.checkCreateResponse(createResource);
 586
 587                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 588
 589         }
 590
 591         @Test(enabled = true)
 592         public void uploadArtifactToResourceFromCsarTest() throws Exception {
 593                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 594                 resourceDetails.setCsarUUID("valid_vf");
 595                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 596                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 597                 BaseRestUtils.checkCreateResponse(createResource);
 598
 599                 User designer = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 600                 ArtifactReqDetails artifactDetails = ElementFactory.getDefaultArtifact("firstArtifact");
 601                 String firstArtifactLabel = artifactDetails.getArtifactLabel();
 602                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(artifactDetails, designer, resourceDetails.getUniqueId());
 603                 ArtifactRestUtils.checkSuccess(addInformationalArtifactToResource);
 604                 RestResponse getResourceResponse = ResourceRestUtils.getResource(resourceDetails.getUniqueId());
 605                 Resource resource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class);
 606                 Map<String, ArtifactDefinition> informationalArtifacts = resource.getArtifacts();
 607                 assertEquals(1, informationalArtifacts.keySet().size());
 608                 Set<String> keySet = informationalArtifacts.keySet();
 609                 assertTrue(keySet.contains(firstArtifactLabel.toLowerCase()));
 610                 Collection<ArtifactDefinition> values = informationalArtifacts.values();
 611                 assertEquals(1, values.size());
 612                 Iterator<ArtifactDefinition> iterator = values.iterator();
 613                 while (iterator.hasNext()) {
 614                         ArtifactDefinition actualArtifact = iterator.next();
 615                         assertTrue(firstArtifactLabel.equals(actualArtifact.getArtifactDisplayName()));
 616                 }
 617
 618                 RestResponse lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designer.getUserId(), LifeCycleStatesEnum.CHECKIN);
 619                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
 620                 lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designer.getUserId(), LifeCycleStatesEnum.CHECKOUT);
 621                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
 622
 623                 ArtifactReqDetails artifactDetails2 = ElementFactory.getDefaultArtifact("secondArtifact");
 624                 artifactDetails2.setArtifactName("secondArtifact");
 625                 addInformationalArtifactToResource = ArtifactRestUtils.addInformationalArtifactToResource(artifactDetails2, designer, resourceDetails.getUniqueId());
 626                 ArtifactRestUtils.checkSuccess(addInformationalArtifactToResource);
 627
 628                 getResourceResponse = ResourceRestUtils.getResource(resourceDetails.getUniqueId());
 629                 resource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class);
 630                 informationalArtifacts = resource.getArtifacts();
 631                 assertEquals(2, informationalArtifacts.keySet().size());
 632                 keySet = informationalArtifacts.keySet();
 633                 assertTrue(keySet.contains(firstArtifactLabel.toLowerCase()));
 634                 assertTrue(keySet.contains(artifactDetails2.getArtifactLabel().toLowerCase()));
 635                 values = informationalArtifacts.values();
 636                 assertEquals(2, values.size());
 637                 ArtifactDefinition[] actualArtifacts = values.toArray(new ArtifactDefinition[2]);
 638                 assertTrue(firstArtifactLabel.equals(actualArtifacts[0].getArtifactDisplayName()));
 639                 assertTrue(artifactDetails2.getArtifactLabel().equals(actualArtifacts[1].getArtifactDisplayName()));
 640         }
 641
 642         /*
 643          * // @Test (enabled = true) public void createUpdateImportResourceFromCsarArtifactsWereNotChangedTest() throws Exception { // User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER); // //back original scar RestResponse
 644          * copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar"); BaseRestUtils.checkSuccess(copyRes);
 645          *
 646          * // resourceDetails.setResourceType(ResourceTypeEnum.VF.name()); // RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails); resourceDetails.setName("test5");
 647          * resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar"); resourceDetails.setCsarVersion("1"); // String invariantUUID = resource.getInvariantUUID(); // // RestResponse changeResourceState =
 648          * LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN); // assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
 649          *
 650          * // BaseRestUtils.checkSuccess(copyRes); // //change name (temporary) resourceDetails.setCsarVersion("2"); resourceDetails.setName("test6"); createResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails,
 651          * resourceDetails.getUniqueId()); Resource updatedResource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class); Map<String, ArtifactDefinition> updatedArtifacts = updatedResource.getDeploymentArtifacts(); for
 652          * (Entry<String, ArtifactDefinition> artifactEntry : resource.getDeploymentArtifacts().entrySet()) { if (updatedArtifacts.containsKey(artifactEntry.getKey())) { ArtifactDefinition currArt = updatedArtifacts.get(artifactEntry.getKey());
 653          * assertEquals(currArt.getArtifactVersion(), artifactEntry.getValue().getArtifactVersion()); assertEquals(currArt.getArtifactUUID(), artifactEntry.getValue().getArtifactUUID()); assertEquals(currArt.getArtifactChecksum(),
 654          * artifactEntry.getValue().getArtifactChecksum()); } } // resourceDetails = ElementFactory.getDefaultResource(); // resourceDetails.setName("test5"); // resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar"); }
 655          */
 656
 657         @Test(enabled = true)
 658         public void createImportResourceFromCsarDissotiateArtifactFromGroupTest() throws Exception {
 659                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 660                 RestResponse copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar");
 661
 662                 // create new resource from Csar
 663                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 664                 resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar");
 665                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 666                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 667                 BaseRestUtils.checkCreateResponse(createResource);
 668                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 669                 String invariantUUID = resource.getInvariantUUID();
 670
 671                 // add artifact from metadata (resource metadata should be updated)
 672                 // RestResponse addInformationalArtifactToResource =
 673                 // ArtifactRestUtils.addInformationalArtifactToResource(ElementFactory.getDefaultArtifact(),
 674                 // sdncModifierDetails, resourceDetails.getUniqueId());
 675                 // ArtifactRestUtils.checkSuccess(addInformationalArtifactToResource);
 676                 resourceDetails.setName("test4");
 677                 RestResponse updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId());
 678                 BaseRestUtils.checkSuccess(updateResource);
 679                 resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class);
 680                 assertEquals(invariantUUID, resource.getInvariantUUID());
 681
 682                 // wrong RI (without node types, resource shouldn't be updated)
 683                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_dissociate.csar", "VF_RI2_G4_withArtifacts.csar");
 684                 BaseRestUtils.checkSuccess(copyRes);
 685                 // change name (temporary)
 686                 resourceDetails.setName("test4");
 687                 updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId());
 688                 BaseRestUtils.checkSuccess(updateResource);
 689                 resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class);
 690                 assertEquals(invariantUUID, resource.getInvariantUUID());
 691
 692                 // back original scar
 693                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar");
 694                 BaseRestUtils.checkSuccess(copyRes);
 695         }
 696
 697         @Test(enabled = true)
 698         public void createImportResourceFromCsarNewgroupTest() throws Exception {
 699                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 700                 RestResponse copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar");
 701
 702                 // create new resource from Csar
 703                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 704                 resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar");
 705                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 706                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 707                 BaseRestUtils.checkCreateResponse(createResource);
 708                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 709                 String invariantUUID = resource.getInvariantUUID();
 710
 711                 // update scar
 712                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_UpdateToscaAndArtifacts.csar", "VF_RI2_G4_withArtifacts.csar");
 713                 BaseRestUtils.checkSuccess(copyRes);
 714
 715                 resourceDetails.setName("test2");
 716                 // change resource metaData (resource should be updated)
 717                 resourceDetails.setDescription("It is new description bla bla bla");
 718                 RestResponse updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId());
 719                 BaseRestUtils.checkSuccess(updateResource);
 720                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 721
 722                 assertEquals(invariantUUID, resource.getInvariantUUID());
 723
 724                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar");
 725                 BaseRestUtils.checkSuccess(copyRes);
 726         }
 727
 728         @Test(enabled = true)
 729         public void createImportResourceFromCsarGetGroupTest() throws Exception {
 730                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 731                 // RestResponse copyRes =
 732                 // copyCsarRest(sdncModifierDetails,"VF_RI2_G4_withArtifacts_a.csar","VF_RI2_G4_withArtifacts.csar");
 733
 734                 // create new resource from Csar
 735                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 736                 resourceDetails.setCsarUUID("VSPPackage");
 737                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 738                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 739                 BaseRestUtils.checkCreateResponse(createResource);
 740                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 741                 String invariantUUID = resource.getInvariantUUID();
 742                 List<GroupDefinition> groups = resource.getGroups();
 743
 744                 GroupDefinition groupWithArtifact = groups.stream().filter(p -> p.getArtifacts() != null && !p.getArtifacts().isEmpty()).findFirst().get();
 745
 746                 RestResponse groupRest = GroupRestUtils.getGroupById(resource, groupWithArtifact.getUniqueId(), sdncModifierDetails);
 747                 BaseRestUtils.checkSuccess(groupRest);
 748
 749                 GroupDefinition groupWithoutArtifact = groups.stream().filter(p -> p.getArtifacts() == null || p.getArtifacts().isEmpty()).findFirst().get();
 750
 751                 groupRest = GroupRestUtils.getGroupById(resource, groupWithoutArtifact.getUniqueId(), sdncModifierDetails);
 752                 BaseRestUtils.checkSuccess(groupRest);
 753         }
 754
 755         @Test(enabled = true)
 756         public void createImportResourceFromCsarUITest() throws Exception {
 757                 RestResponse getResource = null;
 758                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 759                 String payloadName = "valid_vf.csar";
 760                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
 761                 String rootPath = System.getProperty("user.dir");
 762                 Path path = null;
 763                 byte[] data = null;
 764                 String payloadData = null;
 765
 766                 path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf.csar");
 767                 data = Files.readAllBytes(path);
 768                 payloadData = Base64.encodeBase64String(data);
 769                 resourceDetails.setPayloadData(payloadData);
 770
 771                 // create new resource from Csar
 772                 resourceDetails.setCsarUUID(payloadName);
 773                 resourceDetails.setPayloadName(payloadName);
 774                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 775                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 776                 BaseRestUtils.checkCreateResponse(createResource);
 777                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 778                 assertEquals(5, resource.getComponentInstances().size());
 779
 780                 RestResponse changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
 781                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
 782
 783                 // change composition (resource should be updated)
 784                 path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf_b.csar");
 785                 data = Files.readAllBytes(path);
 786                 payloadData = Base64.encodeBase64String(data);
 787                 resourceDetails.setPayloadData(payloadData);
 788                 // change name
 789                 resourceDetails.setName("test1");
 790                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 791                 BaseRestUtils.checkCreateResponse(createResource);
 792                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 793                 assertEquals(2, resource.getComponentInstances().size());
 794
 795                 changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
 796                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
 797
 798                 // change name
 799                 resourceDetails.setName("test2");
 800                 // change resource metaData (resource should be updated)
 801                 resourceDetails.setDescription("It is new description bla bla bla");
 802                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 803                 BaseRestUtils.checkCreateResponse(createResource);
 804                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 805                 assertEquals(2, resource.getComponentInstances().size());
 806
 807                 changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
 808                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
 809
 810                 // wrong RI (without node types, resource shouldn't be updated)
 811                 path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf_c.csar");
 812                 data = Files.readAllBytes(path);
 813                 payloadData = Base64.encodeBase64String(data);
 814                 resourceDetails.setPayloadData(payloadData);
 815                 // change name
 816                 resourceDetails.setName("test3");
 817                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 818                 BaseRestUtils.checkErrorResponse(createResource, ActionStatus.INVALID_NODE_TEMPLATE, "Definitions/tosca_mock_vf.yaml", "nodejs", "tosca.nodes.Weber");
 819                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 820                 assertEquals(null, resource);
 821                 getResource = ResourceRestUtils.getResourceByNameAndVersion(sdncModifierDetails.getUserId(), "test3", resourceDetails.getVersion());
 822                 BaseRestUtils.checkErrorResponse(getResource, ActionStatus.RESOURCE_NOT_FOUND, "test3");
 823
 824                 // create new resource from other Csar
 825                 resourceDetails = ElementFactory.getDefaultImportResource();
 826                 path = Paths.get(rootPath + "/src/main/resources/ci/VF_RI2_G4_withArtifacts.csar");
 827                 data = Files.readAllBytes(path);
 828                 payloadData = Base64.encodeBase64String(data);
 829                 resourceDetails.setPayloadData(payloadData);
 830                 resourceDetails.setPayloadName("VF_RI2_G4_withArtifacts.csar");
 831                 resourceDetails.setName("test4");
 832                 resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar");
 833                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 834                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 835                 BaseRestUtils.checkCreateResponse(createResource);
 836
 837                 changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
 838                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
 839
 840                 // wrong RI (with node types) resource shouldn't be created
 841                 resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts_b.csar");
 842                 path = Paths.get(rootPath + "/src/main/resources/ci/VF_RI2_G4_withArtifacts_b.csar");
 843                 data = Files.readAllBytes(path);
 844                 payloadData = Base64.encodeBase64String(data);
 845                 resourceDetails.setPayloadData(payloadData);
 846                 resourceDetails.setPayloadName("VF_RI2_G4_withArtifacts_b.csar");
 847                 resourceDetails.setName("test5");
 848                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 849                 BaseRestUtils.checkErrorResponse(createResource, ActionStatus.INVALID_NODE_TEMPLATE, "Definitions/VF_RI2_G1.yaml", "ps04_port_0", "org.openecomp.resource.cp.nodes.heat.network.neutron.Portur");
 850         }
 851
 852         @Test(enabled = true)
 853         public void createUpdateImportResourceFromCsarUITest() throws Exception {
 854                 RestResponse getResource = null;
 855                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 856                 String payloadName = "valid_vf.csar";
 857                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
 858                 String rootPath = System.getProperty("user.dir");
 859                 Path path = null;
 860                 byte[] data = null;
 861                 String payloadData = null;
 862
 863                 path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf.csar");
 864                 data = Files.readAllBytes(path);
 865                 payloadData = Base64.encodeBase64String(data);
 866                 resourceDetails.setPayloadData(payloadData);
 867
 868                 // create new resource from Csar
 869                 resourceDetails.setPayloadName(payloadName);
 870                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 871                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 872                 BaseRestUtils.checkCreateResponse(createResource);
 873                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 874                 assertEquals(5, resource.getComponentInstances().size());
 875
 876                 RestResponse changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
 877                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
 878
 879                 // change composition and update resource
 880                 path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf_b.csar");
 881                 data = Files.readAllBytes(path);
 882                 payloadData = Base64.encodeBase64String(data);
 883                 resourceDetails.setPayloadData(payloadData);
 884                 resourceDetails.setUniqueId(resource.getUniqueId());
 885                 // change name
 886                 RestResponse updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId());
 887                 BaseRestUtils.checkSuccess(updateResource);
 888                 resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class);
 889                 assertEquals(2, resource.getComponentInstances().size());
 890
 891                 changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
 892                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
 893
 894                 // change name
 895                 resourceDetails.setName("test2");
 896                 // change resource metaData (resource should be updated)
 897                 resourceDetails.setDescription("It is new description bla bla bla");
 898                 updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId());
 899                 BaseRestUtils.checkSuccess(updateResource);
 900                 resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class);
 901                 assertEquals(2, resource.getComponentInstances().size());
 902
 903                 changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
 904                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
 905
 906                 // try to update resource with wrong RI (without node types, resource
 907                 // shouldn't be updated)
 908                 path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf_c.csar");
 909                 data = Files.readAllBytes(path);
 910                 payloadData = Base64.encodeBase64String(data);
 911                 resourceDetails.setPayloadData(payloadData);
 912                 // change name
 913                 resourceDetails.setName("test3");
 914                 updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId());
 915                 BaseRestUtils.checkErrorResponse(updateResource, ActionStatus.INVALID_NODE_TEMPLATE, "Definitions/tosca_mock_vf.yaml", "nodejs", "tosca.nodes.Weber");
 916                 resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class);
 917                 assertEquals(null, resource);
 918                 getResource = ResourceRestUtils.getResourceByNameAndVersion(sdncModifierDetails.getUserId(), "test3", resourceDetails.getVersion());
 919                 BaseRestUtils.checkErrorResponse(getResource, ActionStatus.RESOURCE_NOT_FOUND, "test3");
 920         }
 921
 922         @Test(enabled = true)
 923         public void createUpdateImportResourceFromCsarTest() throws Exception {
 924                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 925                 RestResponse copyRes = null;
 926                 RestResponse getResource = null;
 927                 ResourceReqDetails resourceDetails = null;
 928                 RestResponse updateResource = null;
 929                 RestResponse createResource = null;
 930                 Resource resource = null;
 931                 RestResponse changeResourceState = null;
 932
 933                 // create new resource from Csar
 934                 copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_a.csar", "valid_vf.csar");
 935                 resourceDetails = ElementFactory.getDefaultResource();
 936                 resourceDetails.setCsarUUID("valid_vf.csar");
 937                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 938                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
 939                 BaseRestUtils.checkCreateResponse(createResource);
 940                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 941                 assertEquals(5, resource.getComponentInstances().size());
 942                 String invariantUUID = resource.getInvariantUUID();
 943
 944                 changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
 945                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
 946
 947                 // change composition and update resource
 948                 copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_b.csar", "valid_vf.csar");
 949                 BaseRestUtils.checkSuccess(copyRes);
 950                 // change name
 951                 resourceDetails.setName("test1");
 952                 updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId());
 953                 BaseRestUtils.checkSuccess(updateResource);
 954                 resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class);
 955                 assertEquals(2, resource.getComponentInstances().size());
 956                 assertEquals(invariantUUID, resource.getInvariantUUID());
 957
 958                 changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
 959                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
 960
 961                 // back original scar
 962                 copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_a.csar", "valid_vf.csar");
 963                 BaseRestUtils.checkSuccess(copyRes);
 964
 965                 // change name
 966                 resourceDetails.setName("test2");
 967                 // change resource metaData and update resource
 968                 resourceDetails.setDescription("It is new description bla bla bla");
 969                 updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId());
 970                 BaseRestUtils.checkSuccess(updateResource);
 971                 resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class);
 972                 assertEquals(5, resource.getComponentInstances().size());
 973                 assertEquals(invariantUUID, resource.getInvariantUUID());
 974
 975                 changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
 976                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
 977
 978                 // back original scar
 979                 copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_a.csar", "valid_vf.csar");
 980                 BaseRestUtils.checkSuccess(copyRes);
 981
 982                 // try to update resource with wrong RI (without node types, resource
 983                 // shouldn't be updated)
 984                 copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_c.csar", "valid_vf.csar");
 985                 BaseRestUtils.checkSuccess(copyRes);
 986                 // change name (temporary)
 987                 resourceDetails.setName("test3");
 988                 updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId());
 989                 BaseRestUtils.checkErrorResponse(updateResource, ActionStatus.INVALID_NODE_TEMPLATE, "Definitions/tosca_mock_vf.yaml", "nodejs", "tosca.nodes.Weber");
 990
 991                 getResource = ResourceRestUtils.getResourceByNameAndVersion(sdncModifierDetails.getUserId(), "test3", resourceDetails.getVersion());
 992                 BaseRestUtils.checkErrorResponse(getResource, ActionStatus.RESOURCE_NOT_FOUND, "test3");
 993                 getResource = ResourceRestUtils.getResourceByNameAndVersion(sdncModifierDetails.getUserId(), "test2", resourceDetails.getVersion());
 994                 BaseRestUtils.checkSuccess(getResource);
 995
 996                 // back original scar
 997                 copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_a.csar", "valid_vf.csar");
 998                 BaseRestUtils.checkSuccess(copyRes);
 999
1000                 // create new resource from Csar
1001                 // back original scar
1002                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar");
1003                 BaseRestUtils.checkSuccess(copyRes);
1004
1005                 resourceDetails = ElementFactory.getDefaultResource();
1006                 resourceDetails.setName("TEST01");
1007                 resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar");
1008                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1009                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1010                 BaseRestUtils.checkCreateResponse(createResource);
1011                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1012
1013                 changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
1014                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1015
1016                 // scar with wrong RI
1017                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_b.csar", "VF_RI2_G4_withArtifacts.csar");
1018                 BaseRestUtils.checkSuccess(copyRes);
1019                 resourceDetails.setDescription("BLA BLA BLA");
1020                 // wrong RI (with node types) resource shouldn't be created
1021                 updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId());
1022                 BaseRestUtils.checkErrorResponse(updateResource, ActionStatus.INVALID_NODE_TEMPLATE, "Definitions/VF_RI2_G1.yaml", "ps04_port_0", "org.openecomp.resource.cp.nodes.heat.network.neutron.Portur");
1023                 // back original scar
1024                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar");
1025                 BaseRestUtils.checkSuccess(copyRes);
1026         }
1027
1028         @Test(enabled = true)
1029         public void createUpdateImportResourceFromCsarWithArtifactsTest() throws Exception {
1030                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
1031                 RestResponse copyRes = null;
1032                 ResourceReqDetails resourceDetails = null;
1033                 RestResponse updateResource = null;
1034                 RestResponse createResource = null;
1035                 Resource resource = null;
1036                 RestResponse changeResourceState = null;
1037
1038                 // back original scar
1039                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar");
1040                 BaseRestUtils.checkSuccess(copyRes);
1041
1042                 resourceDetails = ElementFactory.getDefaultResource();
1043                 resourceDetails.setName("TEST01");
1044                 resourceDetails.setCsarUUID("VF_RI2_G4_withArtifacts.csar");
1045                 resourceDetails.setCsarVersion("1");
1046                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1047                 // create new resource from Csar
1048                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1049                 BaseRestUtils.checkCreateResponse(createResource);
1050                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1051
1052                 List<String> requiredArtifactsOld = resource.getDeploymentArtifacts().get("heat5").getRequiredArtifacts();
1053                 assertTrue(requiredArtifactsOld != null && !requiredArtifactsOld.isEmpty() && requiredArtifactsOld.size() == 3);
1054                 assertTrue(requiredArtifactsOld.contains("hot-nimbus-pcm-volumes_v1.0.yaml"));
1055                 assertTrue(requiredArtifactsOld.contains("nested-pcm_v1.0.yaml"));
1056                 assertTrue(requiredArtifactsOld.contains("hot-nimbus-oam-volumes_v1.0.yaml"));
1057
1058                 // update scar with new artifacts
1059                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_updated.csar", "VF_RI2_G4_withArtifacts.csar");
1060                 BaseRestUtils.checkSuccess(copyRes);
1061                 resourceDetails.setDescription("BLA BLA BLA");
1062                 resourceDetails.setCsarVersion("2");
1063                 updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId());
1064                 BaseRestUtils.checkSuccess(updateResource);
1065                 resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class);
1066
1067                 List<String> requiredArtifactsNew = resource.getDeploymentArtifacts().get("heat5").getRequiredArtifacts();
1068                 assertTrue(requiredArtifactsNew != null && !requiredArtifactsNew.isEmpty() && requiredArtifactsNew.size() == 3);
1069                 assertTrue(requiredArtifactsNew.contains("hot-nimbus-swift-container_v1.0.yaml"));
1070                 assertTrue(requiredArtifactsNew.contains("hot-nimbus-oam-volumes_v1.0.yaml"));
1071                 assertTrue(requiredArtifactsNew.contains("nested-oam_v1.0.yaml"));
1072
1073                 // back original scar
1074                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar", "VF_RI2_G4_withArtifacts.csar");
1075                 BaseRestUtils.checkSuccess(copyRes);
1076         }
1077
1078         @Test(enabled = true)
1079         public void createUpdateImportWithPropertiesFromCsarUITest() throws Exception {
1080                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
1081                 String payloadName = "valid_vf.csar";
1082                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
1083                 String rootPath = System.getProperty("user.dir");
1084                 Path path = null;
1085                 byte[] data = null;
1086                 String payloadData = null;
1087
1088                 path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf.csar");
1089                 data = Files.readAllBytes(path);
1090                 payloadData = Base64.encodeBase64String(data);
1091                 resourceDetails.setPayloadData(payloadData);
1092
1093                 // create new resource from Csar
1094                 resourceDetails.setCsarUUID(payloadName);
1095                 resourceDetails.setPayloadName(payloadName);
1096                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1097                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1098                 BaseRestUtils.checkCreateResponse(createResource);
1099                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1100                 assertEquals(5, resource.getComponentInstances().size());
1101
1102                 RestResponse changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
1103                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1104
1105                 // change composition (add new RI with specified property values)
1106                 path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf_d.csar");
1107                 data = Files.readAllBytes(path);
1108                 payloadData = Base64.encodeBase64String(data);
1109                 resourceDetails.setPayloadData(payloadData);
1110                 // change name
1111                 resourceDetails.setName("test1");
1112                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1113                 BaseRestUtils.checkCreateResponse(createResource);
1114                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1115                 assertEquals(6, resource.getComponentInstances().size());
1116
1117                 changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, sdncModifierDetails, LifeCycleStatesEnum.CHECKIN);
1118                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1119
1120                 // change composition (add new specified property values to existing RI)
1121                 path = Paths.get(rootPath + "/src/main/resources/ci/valid_vf_f.csar");
1122                 data = Files.readAllBytes(path);
1123                 payloadData = Base64.encodeBase64String(data);
1124                 resourceDetails.setPayloadData(payloadData);
1125                 // change name
1126                 resourceDetails.setName("test2");
1127                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1128                 BaseRestUtils.checkCreateResponse(createResource);
1129                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1130                 assertEquals(6, resource.getComponentInstances().size());
1131
1132         }
1133
1134         public static RestResponse copyCsarRest(User sdncModifierDetails, String sourceCsarUuid, String targetCsarUuid) throws Exception {
1135
1136                 Config config = Utils.getConfig();
1137                 String url = String.format(Urls.COPY_CSAR_USING_SIMULATOR, config.getCatalogBeHost(), config.getCatalogBePort(), sourceCsarUuid, targetCsarUuid);
1138                 String userId = sdncModifierDetails.getUserId();
1139                 Map<String, String> headersMap = prepareHeadersMap(userId);
1140                 HttpRequest http = new HttpRequest();
1141
1142                 RestResponse copyCsarResponse = http.httpSendPost(url, "dummy", headersMap);
1143                 if (copyCsarResponse.getErrorCode() != 200) {
1144                         return null;
1145                 }
1146                 return copyCsarResponse;
1147
1148         }
1149
1150         public static RestResponse getCsarRest(User sdncModifierDetails, String sourceCsarUuid) throws Exception {
1151
1152                 Config config = Utils.getConfig();
1153                 String url = String.format(Urls.GET_CSAR_USING_SIMULATOR, config.getCatalogBeHost(), config.getCatalogBePort(), sourceCsarUuid);
1154                 String userId = sdncModifierDetails.getUserId();
1155                 Map<String, String> headersMap = prepareHeadersMap(userId);
1156                 HttpRequest http = new HttpRequest();
1157
1158                 RestResponse copyCsarResponse = http.httpSendGet(url, headersMap);
1159                 if (copyCsarResponse.getErrorCode() != 200) {
1160                         return null;
1161                 }
1162                 return copyCsarResponse;
1163
1164         }
1165
1166         @Test(enabled = true)
1167         public void updateResourceFromCsarHappy() throws Exception {
1168                 RestResponse copyRes = copyCsarRest(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), "valid_vf_a.csar", "valid_vf.csar");
1169                 BaseRestUtils.checkSuccess(copyRes);
1170                 // create
1171                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1172                 resourceDetails.setCsarUUID("valid_vf");
1173                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1174                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1175                 BaseRestUtils.checkCreateResponse(createResource);
1176                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1177                 assertEquals(5, resource.getComponentInstances().size());
1178
1179                 String expectedCsarUUID = resourceDetails.getCsarUUID();
1180                 String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase());
1181
1182                 assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, resource.getCsarUUID()), expectedCsarUUID.equals(resource.getCsarUUID()));
1183                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName()));
1184
1185                 RestResponse getResourceResponse = ResourceRestUtils.getResource(resource.getUniqueId());
1186                 Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class);
1187                 assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, getResource.getCsarUUID()), expectedCsarUUID.equals(getResource.getCsarUUID()));
1188                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName()));
1189
1190                 RestResponse updateResource = ResourceRestUtils.updateResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), resourceDetails.getUniqueId());
1191                 BaseRestUtils.checkSuccess(updateResource);
1192
1193         }
1194
1195         @Test(enabled = true)
1196         public void createResourceFromCsarWithGroupsHappy() throws Exception {
1197
1198                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1199                 resourceDetails.setCsarUUID("csarWithGroups");
1200                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1201                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1202                 BaseRestUtils.checkCreateResponse(createResource);
1203
1204                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1205                 assertEquals(5, resource.getComponentInstances().size());
1206
1207                 assertEquals("verify there are 2 groups", 2, resource.getGroups().size());
1208
1209                 Map<String, String> compNameToUniqueId = resource.getComponentInstances().stream().collect(Collectors.toMap(p -> p.getName(), p -> p.getUniqueId()));
1210
1211                 // Verify 2 members on group1
1212                 // members: [ app_server, mongo_server ]
1213                 String[] membersNameGroup1 = { "app_server", "mongo_server" };
1214                 verifyMembersInResource(resource, compNameToUniqueId, "group1", membersNameGroup1);
1215                 // Verify 4 members on group2
1216                 // members: [ mongo_db, nodejs, app_server, mongo_server ]
1217                 String[] membersNameGroup2 = { "app_server", "mongo_server", "mongo_db", "nodejs" };
1218                 verifyMembersInResource(resource, compNameToUniqueId, "group2", membersNameGroup2);
1219
1220                 // Check OUT
1221                 resourceDetails.setUniqueId(resource.getUniqueId());
1222                 RestResponse changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CHECKIN);
1223                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1224
1225                 changeResourceState = LifecycleRestUtils.changeResourceState(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), LifeCycleStatesEnum.CHECKOUT);
1226                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_SUCCESS, changeResourceState.getErrorCode().intValue());
1227
1228                 Resource checkedOutResource = ResponseParser.parseToObjectUsingMapper(changeResourceState.getResponse(), Resource.class);
1229                 compNameToUniqueId = checkedOutResource.getComponentInstances().stream().collect(Collectors.toMap(p -> p.getName(), p -> p.getUniqueId()));
1230
1231                 // Verify 2 members on group1
1232                 // members: [ app_server, mongo_server ]
1233                 verifyMembersInResource(checkedOutResource, compNameToUniqueId, "group1", membersNameGroup1);
1234                 // Verify 4 members on group2
1235                 // members: [ mongo_db, nodejs, app_server, mongo_server ]
1236                 verifyMembersInResource(checkedOutResource, compNameToUniqueId, "group2", membersNameGroup2);
1237
1238         }
1239
1240         private void verifyMembersInResource(Resource resource, Map<String, String> compNameToUniqueId, String groupName, String[] membersName) {
1241                 GroupDefinition groupDefinition = resource.getGroups().stream().filter(p -> p.getName().equals(groupName)).findFirst().get();
1242                 assertEquals("Verify number of members", membersName.length, groupDefinition.getMembers().size());
1243                 Map<String, String> createdMembers = groupDefinition.getMembers();
1244                 Arrays.asList(membersName).forEach(p -> {
1245                         assertTrue("check member name exist", createdMembers.containsKey(p));
1246                 });
1247
1248                 verifyMembers(createdMembers, compNameToUniqueId);
1249         }
1250
1251         @Test(enabled = true)
1252         public void createResourceFromCsarWithGroupsAndPropertiesHappy() throws Exception {
1253
1254                 RestResponse importNewGroupTypeByName = ImportRestUtils.importNewGroupTypeByName("myHeatStack1", UserRoleEnum.ADMIN);
1255                 // BaseRestUtils.checkCreateResponse(importNewGroupTypeByName);
1256
1257                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1258                 resourceDetails.setCsarUUID("csarWithGroupsWithProps");
1259                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1260                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1261                 BaseRestUtils.checkCreateResponse(createResource);
1262
1263                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1264                 assertEquals(5, resource.getComponentInstances().size());
1265
1266                 assertEquals("verify there are 2 groups", 2, resource.getGroups().size());
1267
1268                 Map<String, String> compNameToUniqueId = resource.getComponentInstances().stream().collect(Collectors.toMap(p -> p.getName(), p -> p.getUniqueId()));
1269
1270                 // Verify 2 members on group1
1271                 // members: [ app_server, mongo_server ]
1272                 List<GroupDefinition> groupDefinition1 = resource.getGroups().stream().filter(p -> p.getName().equals("group1")).collect(Collectors.toList());
1273                 assertEquals("Verify number of members", 2, groupDefinition1.get(0).getMembers().size());
1274                 Map<String, String> createdMembers = groupDefinition1.get(0).getMembers();
1275                 verifyMembers(createdMembers, compNameToUniqueId);
1276
1277                 List<GroupProperty> properties = groupDefinition1.get(0).convertToGroupProperties();
1278                 assertEquals("Verify number of members", 2, properties.size());
1279
1280                 GroupProperty heatFiles = properties.stream().filter(p -> p.getName().equals("heat_files")).findFirst().get();
1281                 assertNotNull("check heat files not empty", heatFiles);
1282                 List<String> heatFilesValue = new ArrayList<>();
1283                 heatFilesValue.add("heat1.yaml");
1284                 heatFilesValue.add("heat2.yaml");
1285                 String heatFilesJson = gson.toJson(heatFilesValue);
1286                 log.debug(heatFiles.getValue());
1287                 assertEquals("check heat files value", heatFilesJson, heatFiles.getValue());
1288
1289                 GroupProperty urlCredential = properties.stream().filter(p -> p.getName().equals("url_credential")).findFirst().get();
1290                 assertNotNull("check heat files not empty", urlCredential);
1291                 log.debug(urlCredential.getValue());
1292                 assertEquals("check url credential", "{\"protocol\":\"protocol1\",\"keys\":{\"keya\":\"valuea\",\"keyb\":\"valueb\"}}", urlCredential.getValue());
1293         }
1294
1295         @Test(enabled = true)
1296         public void createResourceFromCsarWithGroupsAndPropertyInvalidValue() throws Exception {
1297
1298                 RestResponse importNewGroupTypeByName = ImportRestUtils.importNewGroupTypeByName("myHeatStack1", UserRoleEnum.ADMIN);
1299                 // BaseRestUtils.checkCreateResponse(importNewGroupTypeByName);
1300
1301                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1302                 resourceDetails.setCsarUUID("csarWithGroupsInvalidPropertyValue");
1303                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1304                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1305
1306                 BaseRestUtils.checkStatusCode(createResource, "Check bad request error", false, 400);
1307
1308         }
1309
1310         @Test(enabled = true)
1311         public void createResourceFromCsarWithGroupsAndInvalidPropertyName() throws Exception {
1312
1313                 RestResponse importNewGroupTypeByName = ImportRestUtils.importNewGroupTypeByName("myHeatStack1", UserRoleEnum.ADMIN);
1314                 // BaseRestUtils.checkCreateResponse(importNewGroupTypeByName);
1315
1316                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1317                 resourceDetails.setCsarUUID("csarWithGroupsPropertyNotExist");
1318                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1319                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1320
1321                 BaseRestUtils.checkStatusCode(createResource, "Check bad request error", false, 400);
1322                 BaseRestUtils.checkErrorResponse(createResource, ActionStatus.GROUP_PROPERTY_NOT_FOUND, "url_credential111", "group1", "org.openecomp.groups.MyHeatStack1");
1323
1324         }
1325
1326         @Test(enabled = true)
1327         public void createResourceFromCsarGroupTypeNotExist() throws Exception {
1328
1329                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1330                 resourceDetails.setCsarUUID("csarWithGroupsInvalidGroupType");
1331                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1332                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1333
1334                 BaseRestUtils.checkStatusCode(createResource, "Check bad request error", false, 400);
1335                 BaseRestUtils.checkErrorResponse(createResource, ActionStatus.GROUP_TYPE_IS_INVALID, "org.openecomp.groups.stamGroupType");
1336
1337         }
1338
1339         @Test(enabled = true)
1340         public void createResourceFromCsarMemberNotExist() throws Exception {
1341
1342                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1343                 resourceDetails.setCsarUUID("csarWithGroupsInvalidMember");
1344                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1345                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1346
1347                 BaseRestUtils.checkStatusCode(createResource, "Check bad request error", false, 400);
1348                 BaseRestUtils.checkErrorResponse(createResource, ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, "mycomp", "mygroup", ValidationUtils.normaliseComponentName(resourceDetails.getName()), "VF");
1349
1350         }
1351
1352         @Test(enabled = true)
1353         public void createResourceFromCsarMemberNotAllowed() throws Exception {
1354
1355                 RestResponse importNewGroupTypeByName = ImportRestUtils.importNewGroupTypeByName("myHeatStack2", UserRoleEnum.ADMIN);
1356
1357                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1358                 resourceDetails.setCsarUUID("csarWithGroupsNotAllowedMember");
1359                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1360                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1361
1362                 BaseRestUtils.checkStatusCode(createResource, "Check bad request error", false, 400);
1363                 BaseRestUtils.checkErrorResponse(createResource, ActionStatus.GROUP_INVALID_TOSCA_NAME_OF_COMPONENT_INSTANCE, "nodejs", "group1", "org.openecomp.groups.MyHeatStack2");
1364
1365         }
1366
1367         @Test(enabled = true)
1368         public void getResourceFromCsarUuidHappy() throws Exception {
1369                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1370                 resourceDetails.setCsarUUID("tam");
1371                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1372                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1373                 BaseRestUtils.checkCreateResponse(createResource);
1374                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1375                 assertEquals(6, resource.getComponentInstances().size());
1376
1377                 String expectedCsarUUID = resourceDetails.getCsarUUID();
1378                 String expectedToscaResourceName = "org.openecomp.resource.vf." + WordUtils.capitalize(resourceDetails.getName().toLowerCase());
1379
1380                 assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, resource.getCsarUUID()), expectedCsarUUID.equals(resource.getCsarUUID()));
1381                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, resource.getToscaResourceName()), expectedToscaResourceName.equals(resource.getToscaResourceName()));
1382
1383                 RestResponse getResourceResponse = ResourceRestUtils.getLatestResourceFromCsarUuid(resource.getCsarUUID());
1384                 Resource getResource = ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(), Resource.class);
1385                 assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID, getResource.getCsarUUID()), expectedCsarUUID.equals(getResource.getCsarUUID()));
1386                 assertTrue("toscaResourceName : " + buildAssertMessage(expectedToscaResourceName, getResource.getToscaResourceName()), expectedToscaResourceName.equals(getResource.getToscaResourceName()));
1387         }
1388
1389         @Test(enabled = true)
1390         public void getResourceFromCsarResourceNotFound() throws Exception {
1391                 String csarUUID = "tam";
1392                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1393                 resourceDetails.setCsarUUID(csarUUID);
1394                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1395
1396                 RestResponse resResponse = ResourceRestUtils.getLatestResourceFromCsarUuid(csarUUID);
1397
1398                 BaseRestUtils.checkStatusCode(resResponse, "Check bad request error", false, 400);
1399                 BaseRestUtils.checkErrorResponse(resResponse, ActionStatus.RESOURCE_FROM_CSAR_NOT_FOUND, csarUUID);
1400
1401         }
1402
1403         @Test(enabled = true)
1404         public void getResourceFromMissingCsar() throws Exception {
1405                 String csarUUID = "abcdefg12345";
1406                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1407                 resourceDetails.setCsarUUID(csarUUID);
1408                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1409
1410                 RestResponse resResponse = ResourceRestUtils.getLatestResourceFromCsarUuid(csarUUID);
1411
1412                 BaseRestUtils.checkStatusCode(resResponse, "Check bad request error", false, 400);
1413                 BaseRestUtils.checkErrorResponse(resResponse, ActionStatus.RESOURCE_FROM_CSAR_NOT_FOUND, csarUUID);
1414
1415         }
1416
1417         @Test(enabled = true)
1418         public void createUpdateCertifiedImportResourceFromCsarTest() throws Exception {
1419                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
1420                 RestResponse copyRes = copyCsarRest(sdncModifierDetails, "valid_vf_a.csar", "valid_vf.csar");
1421                 RestResponse updateResponse = null;
1422                 String oldName = null;
1423                 // create new resource from Csar
1424                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1425                 resourceDetails.setCsarUUID("valid_vf.csar");
1426                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1427                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1428                 BaseRestUtils.checkCreateResponse(createResource);
1429                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1430                 assertEquals(5, resource.getComponentInstances().size());
1431                 String invariantUUID = resource.getInvariantUUID();
1432
1433                 // change metadata
1434                 // resource name, icon, vendor name, category, template derivedFrom
1435                 oldName = resourceDetails.getName();
1436                 resourceDetails.setName("test1");
1437                 resourceDetails.setIcon("newicon");
1438                 resourceDetails.setVendorName("newname");
1439                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1440                 BaseRestUtils.checkErrorResponse(createResource, ActionStatus.VSP_ALREADY_EXISTS, "valid_vf.csar", oldName);
1441
1442                 updateResponse = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId());
1443                 BaseRestUtils.checkSuccess(updateResponse);
1444
1445                 LifecycleRestUtils.certifyResource(resourceDetails);
1446                 // change metadata
1447                 // resource name, icon, vendor name, category, template derivedFrom
1448                 resourceDetails.setName("test2");
1449                 resourceDetails.setIcon("new icon1");
1450                 resourceDetails.setVendorName("new name1");
1451                 resourceDetails.setDescription("bla bla bla");
1452                 updateResponse = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resourceDetails.getUniqueId());
1453                 BaseRestUtils.checkSuccess(updateResponse);
1454                 resource = ResponseParser.parseToObjectUsingMapper(updateResponse.getResponse(), Resource.class);
1455                 assertEquals(5, resource.getComponentInstances().size());
1456                 assertEquals(invariantUUID, resource.getInvariantUUID());
1457                 assertEquals(resource.getName(), "test1");
1458                 assertEquals(resource.getIcon(), "newicon");
1459                 assertEquals(resource.getVendorName(), "newname");
1460                 assertEquals(resource.getDescription(), "bla bla bla");
1461                 assertEquals(resource.getTags().contains("test2"), false);
1462         }
1463
1464         @Test
1465         public void createImportRIRelationByCapNameFromCsarUITest() throws Exception {
1466                 Resource resource = ResourceRestUtils.importResourceFromCsar("vmmc_relate_by_cap_name.csar");
1467                 // assert all relations created
1468                 assertEquals(80, resource.getComponentInstancesRelations().size());
1469         }
1470
1471         @Test
1472         public void createImportRIRelationByCapNameFromCsarUITest2() throws Exception {
1473                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
1474                 String payloadName = "vf_relate_by_cap_name.csar";
1475                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
1476                 String rootPath = System.getProperty("user.dir");
1477                 Path path = null;
1478                 byte[] data = null;
1479                 String payloadData = null;
1480
1481                 path = Paths.get(rootPath + CSARS_PATH + "vf_relate_by_cap_name.csar");
1482                 data = Files.readAllBytes(path);
1483                 payloadData = Base64.encodeBase64String(data);
1484                 resourceDetails.setPayloadData(payloadData);
1485
1486                 // create new resource from Csar
1487                 resourceDetails.setCsarUUID(payloadName);
1488                 resourceDetails.setPayloadName(payloadName);
1489                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1490                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1491                 BaseRestUtils.checkCreateResponse(createResource);
1492                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1493                 // assert relations created: 1.by name: virtual_linkable. 2.by name:
1494                 // link
1495                 Map<String, ComponentInstance> nodes = resource.getComponentInstances().stream().collect(Collectors.toMap(n -> n.getName(), n -> n));
1496                 Map<String, CapabilityDefinition> capabilities = nodes.get("elinenode").getCapabilities().get("tosca.capabilities.network.Linkable").stream().collect(Collectors.toMap(e -> e.getName(), e -> e));
1497                 String cp1Uid = nodes.get("cp1node").getUniqueId();
1498                 String cp2Uid = nodes.get("cp2node").getUniqueId();
1499                 Map<String, List<RequirementCapabilityRelDef>> mappedByReqOwner = resource.getComponentInstancesRelations().stream().collect(Collectors.groupingBy(e -> e.getFromNode()));
1500                 assertEquals(mappedByReqOwner.get(cp1Uid).get(0).getRelationships().get(0).getRelation().getCapabilityUid(), capabilities.get("virtual_linkable").getUniqueId());
1501                 assertEquals(mappedByReqOwner.get(cp2Uid).get(0).getRelationships().get(0).getRelation().getCapabilityUid(), capabilities.get("link").getUniqueId());
1502         }
1503
1504         @Test(enabled = true)
1505         public void importCsarCheckVfHeatEnv() throws Exception {
1506                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1507                 resourceDetails.setCsarUUID("csar_1");
1508                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1509                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1510                 BaseRestUtils.checkCreateResponse(createResource);
1511                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1512
1513
1514                 Map<String, ArtifactDefinition> deploymentArtifacts = resource.getDeploymentArtifacts();
1515                 assertNotNull(deploymentArtifacts);
1516                 // 2 lisence, 1 heat, 1 heatenv
1517                 assertEquals(4, deploymentArtifacts.size());
1518
1519                 ArtifactDefinition artifactHeat = deploymentArtifacts.get("heat0");
1520                 assertNotNull(artifactHeat);
1521
1522                 ArtifactDefinition artifactHeatEnv = deploymentArtifacts.get("heat0env");
1523                 assertNotNull(artifactHeatEnv);
1524
1525                 assertEquals(artifactHeat.getUniqueId(), artifactHeatEnv.getGeneratedFromId());
1526                 assertEquals("VF HEAT ENV", artifactHeatEnv.getArtifactDisplayName());
1527                 assertEquals("HEAT_ENV", artifactHeatEnv.getArtifactType());
1528                 assertEquals("VF Auto-generated HEAT Environment deployment artifact", artifactHeatEnv.getDescription());
1529
1530                 String designerUserId = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER).getUserId();
1531                 String testerUserId = ElementFactory.getDefaultUser(UserRoleEnum.TESTER).getUserId();
1532                 RestResponse lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKIN);
1533                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
1534                 lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKOUT);
1535                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
1536                 lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CHECKIN);
1537                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
1538                 lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, designerUserId, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1539                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
1540                 lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUserId, LifeCycleStatesEnum.STARTCERTIFICATION);
1541                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
1542                 lifecycleChangeResponse = LifecycleRestUtils.changeResourceState(resourceDetails, testerUserId, LifeCycleStatesEnum.CERTIFY);
1543                 LifecycleRestUtils.checkSuccess(lifecycleChangeResponse);
1544                 Resource certifiedResource = ResponseParser.parseToObjectUsingMapper(lifecycleChangeResponse.getResponse(), Resource.class);
1545
1546
1547                 User modifier = new User();
1548                 modifier.setUserId(designerUserId);
1549
1550                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService("newtestservice1", ServiceCategoriesEnum.MOBILITY, designerUserId);
1551
1552                 RestResponse serviceRes = ServiceRestUtils.createService(serviceDetails, modifier);
1553                 ResourceRestUtils.checkCreateResponse(serviceRes);
1554                 Service service =  ResponseParser.parseToObjectUsingMapper(serviceRes.getResponse(), Service.class);
1555
1556                 ComponentInstanceReqDetails resourceInstanceReqDetails = ElementFactory.getComponentInstance(certifiedResource);
1557                 RestResponse createResourceInstanceResponse = ComponentInstanceRestUtils.createComponentInstance(resourceInstanceReqDetails, modifier, service.getUniqueId(), service.getComponentType());
1558                 BaseRestUtils.checkCreateResponse(createResourceInstanceResponse);
1559                 RestResponse serviceByGet = ServiceRestUtils.getService(service.getUniqueId());
1560                 service =  ResponseParser.parseToObjectUsingMapper(serviceByGet.getResponse(), Service.class);
1561
1562                 List<ComponentInstance> componentInstances = service.getComponentInstances();
1563                 assertNotNull(componentInstances);
1564
1565                 assertEquals(1, componentInstances.size());
1566                 ComponentInstance ci = componentInstances.get(0);
1567                 Map<String, ArtifactDefinition> instDepArtifacts = ci.getDeploymentArtifacts();
1568                 assertNotNull(instDepArtifacts);
1569                 ArtifactDefinition instArtifactHeat = instDepArtifacts.get("heat0");
1570                 assertNotNull(instArtifactHeat);
1571
1572                 ArtifactDefinition instArtifactHeatEnv = instDepArtifacts.get("heat0env");
1573                 assertNotNull(instArtifactHeatEnv);
1574                 assertEquals(artifactHeat.getUniqueId(), instArtifactHeatEnv.getGeneratedFromId());
1575                 assertEquals("HEAT ENV", instArtifactHeatEnv.getArtifactDisplayName());
1576                 assertEquals("HEAT_ENV", instArtifactHeatEnv.getArtifactType());
1577
1578                 assertEquals(artifactHeat.getUniqueId(), instArtifactHeat.getUniqueId());
1579                 //different artifacts
1580                 assertTrue( !artifactHeatEnv.getUniqueId().equals(instArtifactHeat.getUniqueId()) );
1581
1582
1583         }
1584
1585         @Test(enabled = true)
1586         public void createAndUpdateCsarCheckVfHeatEnv() throws Exception {
1587                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1588                 resourceDetails.setCsarUUID("orig2G_org");
1589                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1590                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1591                 BaseRestUtils.checkCreateResponse(createResource);
1592                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1593
1594
1595                 Map<String, ArtifactDefinition> deploymentArtifacts = resource.getDeploymentArtifacts();
1596                 assertNotNull(deploymentArtifacts);
1597
1598                 assertEquals(13, deploymentArtifacts.size());
1599
1600                 ArtifactDefinition artifactHeat = deploymentArtifacts.get("heat0");
1601                 assertNotNull(artifactHeat);
1602
1603                 ArtifactDefinition artifactHeatEnv = deploymentArtifacts.get("heat0env");
1604                 assertNotNull(artifactHeatEnv);
1605
1606                 assertEquals(artifactHeat.getUniqueId(), artifactHeatEnv.getGeneratedFromId());
1607                 assertEquals("VF HEAT ENV", artifactHeatEnv.getArtifactDisplayName());
1608                 assertEquals("HEAT_ENV", artifactHeatEnv.getArtifactType());
1609                 assertEquals("VF Auto-generated HEAT Environment deployment artifact", artifactHeatEnv.getDescription());
1610
1611                 List<GroupDefinition>  groups = resource.getGroups();
1612                 assertEquals(2, groups.size());
1613                 GroupDefinition group1 = groups.stream().filter(p -> p.getName().contains("module-0")).findAny().get();
1614                 GroupDefinition group2 = groups.stream().filter(p -> p.getName().contains("module-1")).findAny().get();
1615                 assertEquals(11, group1.getArtifacts().size());
1616                 assertEquals(3, group2.getArtifacts().size());
1617
1618                 resourceDetails.setCsarUUID("orig2G_update");
1619
1620                 RestResponse updateResource = ResourceRestUtils.updateResource(resourceDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), resourceDetails.getUniqueId());
1621                 BaseRestUtils.checkSuccess(updateResource);
1622
1623                 resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class);
1624
1625
1626                 Map<String, ArtifactDefinition> deploymentArtifactsUpd = resource.getDeploymentArtifacts();
1627                 assertNotNull(deploymentArtifactsUpd);
1628
1629                 assertEquals(13, deploymentArtifactsUpd.size());
1630
1631                 ArtifactDefinition artifactHeatUpd = deploymentArtifacts.get("heat0");
1632                 assertNotNull(artifactHeatUpd);
1633
1634                 ArtifactDefinition artifactHeatEnvUpd = deploymentArtifacts.get("heat0env");
1635                 assertNotNull(artifactHeatEnvUpd);
1636
1637                 groups = resource.getGroups();
1638                 assertEquals(2, groups.size());
1639                 assertEquals(7, groups.get(0).getArtifacts().size());
1640                 assertEquals(7, groups.get(1).getArtifacts().size());
1641
1642
1643         }
1644
1645         @Test
1646         public void importInnerVfcWithArtifactsSucceed() throws Exception {
1647                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
1648                 String rootPath = System.getProperty("user.dir");
1649                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
1650
1651                 String payloadName = "ImportArtifactsToVFC.csar";
1652                 Path path = Paths.get(rootPath + CSARS_PATH + "ImportArtifactsToVFC.csar");
1653                 byte[] data = Files.readAllBytes(path);
1654                 String payloadData = Base64.encodeBase64String(data);
1655                 resourceDetails.setPayloadData(payloadData);
1656                 resourceDetails.setPayloadName(payloadName);
1657                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1658
1659                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1660                 BaseRestUtils.checkCreateResponse(createResource);
1661                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1662
1663                 List<ComponentInstance> componentInstances = resource.getComponentInstances();
1664                 List<ComponentInstance> reducedComponentInstances = componentInstances.stream()
1665                                 .filter(ci->ci.getNormalizedName().contains("server_sm"))
1666                                 .collect(Collectors.toList());
1667                 assertTrue(!reducedComponentInstances.isEmpty() && reducedComponentInstances.size() == 2);
1668                 reducedComponentInstances.stream().forEach(ci->isValidArtifacts(ci));
1669
1670                 payloadName = "ImportArtifactsToVFC_empty.csar";
1671                 path = Paths.get(rootPath + CSARS_PATH + "ImportArtifactsToVFC_empty.csar");
1672                 data = Files.readAllBytes(path);
1673                 payloadData = Base64.encodeBase64String(data);
1674                 resourceDetails.setName(resourceDetails.getName()+"2");
1675                 resourceDetails.setPayloadData(payloadData);
1676                 resourceDetails.setPayloadName(payloadName);
1677                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1678
1679                 createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1680                 BaseRestUtils.checkCreateResponse(createResource);
1681                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1682
1683                 componentInstances = resource.getComponentInstances();
1684                 reducedComponentInstances = componentInstances.stream()
1685                                 .filter(ci->ci.getNormalizedName().contains("server_sm"))
1686                                 .collect(Collectors.toList());
1687                 assertTrue(!reducedComponentInstances.isEmpty() && reducedComponentInstances.size() == 2);
1688                 reducedComponentInstances.stream()
1689                 .forEach(ci->assertTrue(
1690                                 (ci.getDeploymentArtifacts()==null || ci.getDeploymentArtifacts().isEmpty()) &&
1691                                 (ci.getArtifacts()==null || ci.getArtifacts().isEmpty()))
1692                                 );
1693         }
1694
1695         @SuppressWarnings("unchecked")
1696         @Test
1697         public void importInnerVfcWithArtifactsUpdateSucceed() throws Exception {
1698                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
1699                 String rootPath = System.getProperty("user.dir");
1700                 ImportReqDetails resourceDetails = ElementFactory.getDefaultImportResource();
1701
1702                 String payloadName = "vfc_artifacts.csar";
1703                 Path path = Paths.get(rootPath + CSARS_PATH + payloadName);
1704                 byte[] data = Files.readAllBytes(path);
1705                 String payloadData = Base64.encodeBase64String(data);
1706                 resourceDetails.setPayloadData(payloadData);
1707                 resourceDetails.setPayloadName(payloadName);
1708                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
1709
1710                 Map<String,String> validCreatedInformationalArtifactVersions = new HashMap<>();
1711                 validCreatedInformationalArtifactVersions.put("GuideInfoDelete.mib","1");
1712                 validCreatedInformationalArtifactVersions.put("GuideInfoUpdate.mib","1");
1713                 validCreatedInformationalArtifactVersions.put("OtherInfoIgnore.mib","1");
1714
1715                 Map<String,String> validCreatedDeploymentArtifactVersions = new HashMap<>();
1716                 validCreatedDeploymentArtifactVersions.put("PollDelete.mib","1");
1717                 validCreatedDeploymentArtifactVersions.put("PollUpdate.mib","1");
1718                 validCreatedDeploymentArtifactVersions.put("TrapDelete.mib","1");
1719                 validCreatedDeploymentArtifactVersions.put("TrapUpdate.mib","1");
1720
1721                 Map<String,String> validUpdatedInformationalArtifactVersions = new HashMap<>();
1722                 validUpdatedInformationalArtifactVersions.put("GuideInfoNew.mib","1");
1723                 validUpdatedInformationalArtifactVersions.put("GuideInfoUpdate.mib","2");
1724                 validUpdatedInformationalArtifactVersions.put("OtherInfoIgnore.mib","1");
1725
1726                 Map<String,String> validUpdatedDeploymentArtifactVersions = new HashMap<>();
1727                 validUpdatedDeploymentArtifactVersions.put("PollNew.mib","1");
1728                 validUpdatedDeploymentArtifactVersions.put("PollUpdate.mib","2");
1729                 validUpdatedDeploymentArtifactVersions.put("TrapNew.mib","1");
1730                 validUpdatedDeploymentArtifactVersions.put("TrapUpdate.mib","2");
1731
1732                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails, sdncModifierDetails);
1733                 BaseRestUtils.checkCreateResponse(createResource);
1734                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
1735
1736                 List<ComponentInstance> componentInstances = resource.getComponentInstances().stream()
1737                                 .filter(ci->ci.getNormalizedName().contains("ltm_server"))
1738                                 .collect(Collectors.toList());
1739                 assertTrue(!componentInstances.isEmpty() && componentInstances.size() == 1);
1740                 ComponentInstance componentInstance = componentInstances.get(0);
1741                 assertTrue(!componentInstance.getArtifacts().isEmpty() && componentInstance.getArtifacts().size() == 3);
1742                 componentInstance.getArtifacts().values().stream()
1743                 .forEach(a->assertTrue(validCreatedInformationalArtifactVersions.containsKey(a.getArtifactName()) &&
1744                                 validCreatedInformationalArtifactVersions.get(a.getArtifactName()).equals(a.getArtifactVersion())));
1745
1746                 assertTrue(!componentInstance.getDeploymentArtifacts().isEmpty() && componentInstance.getDeploymentArtifacts().size() == 4);
1747                 componentInstance.getDeploymentArtifacts().values().stream()
1748                 .forEach(a->assertTrue(validCreatedDeploymentArtifactVersions.containsKey(a.getArtifactName()) &&
1749                                 validCreatedDeploymentArtifactVersions.get(a.getArtifactName()).equals(a.getArtifactVersion())));
1750
1751                 payloadName = "vfc_artifacts_update.csar";
1752                 path = Paths.get(rootPath + CSARS_PATH + payloadName);
1753                 data = Files.readAllBytes(path);
1754                 payloadData = Base64.encodeBase64String(data);
1755                 resourceDetails.setPayloadData(payloadData);
1756                 resourceDetails.setPayloadName(payloadName);
1757
1758                 RestResponse updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId());
1759                 BaseRestUtils.checkSuccess(updateResource);
1760                 resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class);
1761
1762                 componentInstances = resource.getComponentInstances().stream()
1763                                 .filter(ci->ci.getNormalizedName().contains("ltm_server"))
1764                                 .collect(Collectors.toList());
1765                 assertTrue(!componentInstances.isEmpty() && componentInstances.size() == 1);
1766                 componentInstance = componentInstances.get(0);
1767                 assertTrue(!componentInstance.getArtifacts().isEmpty() && componentInstance.getArtifacts().size() == 3);
1768                 componentInstance.getArtifacts().values().stream()
1769                 .forEach(a->assertTrue(validUpdatedInformationalArtifactVersions.containsKey(a.getArtifactName()) &&
1770                                 validUpdatedInformationalArtifactVersions.get(a.getArtifactName()).equals(a.getArtifactVersion())));
1771
1772                 assertTrue(!componentInstance.getDeploymentArtifacts().isEmpty() && componentInstance.getDeploymentArtifacts().size() == 4);
1773                 componentInstance.getDeploymentArtifacts().values().stream()
1774                 .forEach(a->assertTrue(validUpdatedDeploymentArtifactVersions.containsKey(a.getArtifactName()) &&
1775                                 validUpdatedDeploymentArtifactVersions.get(a.getArtifactName()).equals(a.getArtifactVersion())));
1776
1777
1778                 payloadName = "vfc_artifacts_delete_all.csar";
1779                 path = Paths.get(rootPath + CSARS_PATH + payloadName);
1780                 data = Files.readAllBytes(path);
1781                 payloadData = Base64.encodeBase64String(data);
1782                 resourceDetails.setPayloadData(payloadData);
1783                 resourceDetails.setPayloadName(payloadName);
1784
1785                 updateResource = ResourceRestUtils.updateResource(resourceDetails, sdncModifierDetails, resource.getUniqueId());
1786                 BaseRestUtils.checkSuccess(updateResource);
1787                 resource = ResponseParser.parseToObjectUsingMapper(updateResource.getResponse(), Resource.class);
1788
1789                 componentInstances = resource.getComponentInstances().stream()
1790                                 .filter(ci->ci.getNormalizedName().contains("ltm_server"))
1791                                 .collect(Collectors.toList());
1792                 assertTrue(!componentInstances.isEmpty() && componentInstances.size() == 1);
1793                 componentInstance = componentInstances.get(0);
1794                 assertTrue(componentInstance.getArtifacts() == null || componentInstance.getArtifacts().isEmpty());
1795                 assertTrue(componentInstance.getDeploymentArtifacts() == null || componentInstance.getDeploymentArtifacts().isEmpty());
1796         }
1797
1798         private void isValidArtifacts(ComponentInstance ci) {
1799                 assertTrue(!ci.getDeploymentArtifacts().isEmpty() && ci.getDeploymentArtifacts().size() == 11);
1800                 ci.getDeploymentArtifacts().values().stream()
1801                                                  .forEach(a->assertTrue(a.getArtifactName().startsWith("Some")));
1802
1803                 assertTrue(!ci.getArtifacts().isEmpty() && ci.getArtifacts().size() == 1);
1804                 ci.getArtifacts().values().stream()
1805                                                  .forEach(a->assertTrue(a.getArtifactName().startsWith("Process")));
1806         }
1807
1808         private void verifyMembers(Map<String, String> createdMembers, Map<String, String> compNameToUniqueId) {
1809                 for (Map.Entry<String, String> entry : createdMembers.entrySet()) {
1810                         String key = entry.getKey();
1811                         String value = entry.getValue();
1812                         String comparedValue = compNameToUniqueId.get(key);
1813
1814                         assertEquals("compare instance ids", comparedValue, value);
1815                 }
1816
1817         }
1818
1819         private static Map<String, String> prepareHeadersMap(String userId) {
1820                 Map<String, String> headersMap = new HashMap<String, String>();
1821                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), "application/json");
1822                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), "application/json");
1823                 if (userId != null) {
1824                         headersMap.put(HttpHeaderEnum.USER_ID.getValue(), userId);
1825                 }
1826                 return headersMap;
1827         }
1828
1829 }