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