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

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