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

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