asdc-tests/src/main/java/org/openecomp/sdc/ci/tests/execute/devCI/ToscaGroupInsideVF.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.devCI;
  22
  23 import java.util.HashMap;
  24 import java.util.Map;
  25
  26 import org.apache.commons.lang3.tuple.Pair;
  27 import org.junit.Rule;
  28 import org.junit.rules.TestName;
  29 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  30 import org.openecomp.sdc.be.model.Component;
  31 import org.openecomp.sdc.be.model.Resource;
  32 import org.openecomp.sdc.be.model.Service;
  33 import org.openecomp.sdc.be.model.User;
  34 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  35 import org.openecomp.sdc.ci.tests.api.Urls;
  36 import org.openecomp.sdc.ci.tests.config.Config;
  37 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  38 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  39 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  40 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  41 import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum;
  42 import org.openecomp.sdc.ci.tests.datatypes.http.HttpRequest;
  43 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  44 import org.openecomp.sdc.ci.tests.tosca.datatypes.ToscaDefinition;
  45 import org.openecomp.sdc.ci.tests.utils.ToscaParserUtils;
  46 import org.openecomp.sdc.ci.tests.utils.Utils;
  47 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  48 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  49 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  50 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  51 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  52 import org.openecomp.sdc.ci.tests.utils.validation.CsarValidationUtils;
  53 import org.slf4j.Logger;
  54 import org.slf4j.LoggerFactory;
  55 import org.testng.annotations.Test;
  56
  57 public class ToscaGroupInsideVF extends ComponentBaseTest {
  58         private static Logger logger = LoggerFactory.getLogger(ToscaGroupInsideVF.class.getName());
  59
  60         @Rule
  61         public static TestName name = new TestName();
  62
  63         public ToscaGroupInsideVF() {
  64                 super(name, ToscaGroupInsideVF.class.getName());
  65         }
  66
  67         @Test
  68         public void createResourceFromCsarArts() throws Exception {
  69
  70                 // String csar = getCsar();
  71                 // parseCsar(csar);
  72                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
  73                 resourceDetails.setCsarUUID("VF_RI2_G6_withArtifacts");
  74                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
  75                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
  76                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
  77                 BaseRestUtils.checkCreateResponse(createResource);
  78                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
  79
  80                 Component resourceObject = AtomicOperationUtils
  81                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
  82                 Resource vfManual = AtomicOperationUtils.createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true)
  83                                 .left().value();
  84                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.OTHER, vfManual, UserRoleEnum.DESIGNER, true, true);
  85                 AtomicOperationUtils.changeComponentState(vfManual, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true)
  86                                 .getLeft();
  87
  88                 Service service = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
  89                 AtomicOperationUtils
  90                                 .addComponentInstanceToComponentContainer(resourceObject, service, UserRoleEnum.DESIGNER, true).left()
  91                                 .value();
  92                 AtomicOperationUtils.addComponentInstanceToComponentContainer(vfManual, service, UserRoleEnum.DESIGNER, true)
  93                                 .left().value();
  94                 AtomicOperationUtils.getServiceObject(service, UserRoleEnum.DESIGNER);
  95                 AtomicOperationUtils
  96                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFICATIONREQUEST, true)
  97                                 .getLeft();
  98                 AtomicOperationUtils
  99                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CANCELCERTIFICATION, true)
 100                                 .getLeft();
 101                 AtomicOperationUtils
 102                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFICATIONREQUEST, true)
 103                                 .getLeft();
 104
 105         }
 106
 107         @Test
 108         public void soferTest() throws Exception {
 109
 110                 // String csar = getCsar();
 111                 // parseCsar(csar);
 112                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 113                 resourceDetails.setCsarUUID("sofer");
 114                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 115                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
 116                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 117                 BaseRestUtils.checkCreateResponse(createResource);
 118                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 119
 120         }
 121
 122         @Test
 123         public void createVFwith2VLs() throws Exception {
 124
 125                 // String csar = getCsar();
 126                 // parseCsar(csar);
 127                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 128                 resourceDetails.setCsarUUID("VSPPackage");
 129                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 130                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
 131                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 132                 BaseRestUtils.checkCreateResponse(createResource);
 133                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 134
 135                 Component resourceObject = AtomicOperationUtils
 136                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 137                 Resource vfManual = AtomicOperationUtils.createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true)
 138                                 .left().value();
 139                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.OTHER, vfManual, UserRoleEnum.DESIGNER, true, true);
 140                 AtomicOperationUtils.changeComponentState(vfManual, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true)
 141                                 .getLeft();
 142
 143                 Service service = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
 144                 AtomicOperationUtils
 145                                 .addComponentInstanceToComponentContainer(resourceObject, service, UserRoleEnum.DESIGNER, true).left()
 146                                 .value();
 147                 AtomicOperationUtils.addComponentInstanceToComponentContainer(vfManual, service, UserRoleEnum.DESIGNER, true)
 148                                 .left().value();
 149                 AtomicOperationUtils.getServiceObject(service, UserRoleEnum.DESIGNER);
 150                 AtomicOperationUtils
 151                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFICATIONREQUEST, true)
 152                                 .getLeft();
 153                 AtomicOperationUtils
 154                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CANCELCERTIFICATION, true)
 155                                 .getLeft();
 156                 AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true)
 157                                 .getLeft();
 158
 159         }
 160
 161         @Test // (enabled = false)
 162         public void createResourceFromCsarHappy() throws Exception {
 163                 // String csarUUID = "VF_RI2_G2_withArtifacts";
 164                 String csarUUID = "VF_RI2_G1_Invalid";
 165                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 166                 resourceDetails.setCsarUUID(csarUUID);
 167                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 168                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
 169                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 170                 BaseRestUtils.checkCreateResponse(createResource);
 171                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 172                 CsarValidationUtils.validateCsarVfArtifact(csarUUID, resource);
 173         }
 174
 175         @Test // (enabled = false)
 176         public void createResourceFromCsarWithProperty() throws Exception {
 177                 String csarUUID = "VF_RI2_G4_withArtifacts";
 178                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 179                 resourceDetails.setCsarUUID(csarUUID);
 180                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 181                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
 182                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 183                 BaseRestUtils.checkCreateResponse(createResource);
 184                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 185                 CsarValidationUtils.validateCsarVfArtifact(csarUUID, resource);
 186         }
 187
 188         @Test // (enabled = false)
 189         public void UpdateCsarWithNonExistingResourceInstanceFail() throws Exception {
 190
 191                 // String csarUUID = "VF_RI2_G1-RI_NotExist";
 192                 // String csarUUID = "nested3";
 193
 194                 // String csarUUID = "VF_RI2_G1_Invalid_WithArtifacts";
 195                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 196
 197                 RestResponse copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar",
 198                                 "VF_RI2_G4_withArtifacts.csar");
 199                 BaseRestUtils.checkSuccess(copyRes);
 200                 String csarUUID = "VF_RI2_G4_withArtifacts.csar";
 201
 202                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 203                 resourceDetails.setCsarUUID(csarUUID);
 204                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 205                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
 206                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 207                 BaseRestUtils.checkCreateResponse(createResource);
 208                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 209
 210                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifactsRI_FAIL.csar",
 211                                 "VF_RI2_G4_withArtifacts.csar");
 212                 BaseRestUtils.checkSuccess(copyRes);
 213
 214                 resourceDetails.setName(resource.getName());
 215                 // resourceDetails.setVendorName("Govnuk");
 216                 // resourceDetails.setDescription("Other");
 217                 RestResponse createResource2 = ResourceRestUtils.createResource(resourceDetails,
 218                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 219                 BaseRestUtils.checkCreateResponse(createResource2);
 220                 Resource resource2 = ResponseParser.parseToObjectUsingMapper(createResource2.getResponse(), Resource.class);
 221
 222                 CsarValidationUtils.validateCsarVfArtifact(csarUUID, resource);
 223                 ToscaDefinition toscaDefinition = ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID);
 224                 CsarValidationUtils.validateToscaDefinitonObjectVsResource(toscaDefinition, resource);
 225
 226                 // CsarValidationUtils.validateCsarVfArtifact(csarUUID2, resource2);
 227                 // ToscaDefinition toscaDefinition2 =
 228                 // ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID2);
 229                 // CsarValidationUtils.validateToscaDefinitonObjectVsResource(toscaDefinition2,
 230                 // resource2);
 231
 232                 // Csar csar = parserTocsarObject(csarUUID);
 233                 // validateCsarVsResourceObj(csar, resource);
 234                 // csar.node_types();
 235
 236         }
 237
 238         @Test // (enabled = false)
 239         public void UpdateCsarWithSameCsarDifferentMetadata() throws Exception {
 240
 241                 // User sdncModifierDetails =
 242                 // ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 243                 // RestResponse copyRes =
 244                 // copyCsarRest(sdncModifierDetails,"VF_RI2_G4_withArtifacts_a.csar","VF_RI2_G4_withArtifacts.csar");
 245                 // BaseRestUtils.checkSuccess(copyRes);
 246                 String csarUUID = "VF_RI2_G4_withArtifacts.csar";
 247
 248                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 249                 resourceDetails.setCsarUUID(csarUUID);
 250                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 251                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
 252                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 253                 BaseRestUtils.checkCreateResponse(createResource);
 254                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 255
 256                 resourceDetails.setName(resource.getName());
 257                 resourceDetails.setVendorName("Govnuk");
 258                 resourceDetails.setDescription("Other");
 259                 RestResponse createResource2 = ResourceRestUtils.createResource(resourceDetails,
 260                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 261                 BaseRestUtils.checkCreateResponse(createResource2);
 262                 Resource resource2 = ResponseParser.parseToObjectUsingMapper(createResource2.getResponse(), Resource.class);
 263
 264                 CsarValidationUtils.validateCsarVfArtifact(csarUUID, resource);
 265                 ToscaDefinition toscaDefinition = ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID);
 266                 CsarValidationUtils.validateToscaDefinitonObjectVsResource(toscaDefinition, resource);
 267
 268                 // CsarValidationUtils.validateCsarVfArtifact(csarUUID2, resource2);
 269                 // ToscaDefinition toscaDefinition2 =
 270                 // ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID2);
 271                 // CsarValidationUtils.validateToscaDefinitonObjectVsResource(toscaDefinition2,
 272                 // resource2);
 273
 274                 // Csar csar = parserTocsarObject(csarUUID);
 275                 // validateCsarVsResourceObj(csar, resource);
 276                 // csar.node_types();
 277
 278         }
 279
 280         @Test // (enabled = false)
 281         public void UpdateCsarWithSameCsar() throws Exception {
 282
 283                 // User sdncModifierDetails =
 284                 // ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 285                 // RestResponse copyRes =
 286                 // copyCsarRest(sdncModifierDetails,"VF_RI2_G4_withArtifacts_a.csar","VF_RI2_G4_withArtifacts.csar");
 287                 // BaseRestUtils.checkSuccess(copyRes);
 288                 String csarUUID = "VF_RI2_G4_withArtifacts.csar";
 289
 290                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 291                 resourceDetails.setCsarUUID(csarUUID);
 292                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 293                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
 294                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 295                 BaseRestUtils.checkCreateResponse(createResource);
 296                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 297
 298                 resourceDetails.setName(resource.getName());
 299                 RestResponse createResource2 = ResourceRestUtils.createResource(resourceDetails,
 300                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 301                 BaseRestUtils.checkCreateResponse(createResource2);
 302                 Resource resource2 = ResponseParser.parseToObjectUsingMapper(createResource2.getResponse(), Resource.class);
 303
 304                 CsarValidationUtils.validateCsarVfArtifact(csarUUID, resource);
 305                 ToscaDefinition toscaDefinition = ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID);
 306                 CsarValidationUtils.validateToscaDefinitonObjectVsResource(toscaDefinition, resource);
 307
 308                 // CsarValidationUtils.validateCsarVfArtifact(csarUUID2, resource2);
 309                 // ToscaDefinition toscaDefinition2 =
 310                 // ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID2);
 311                 // CsarValidationUtils.validateToscaDefinitonObjectVsResource(toscaDefinition2,
 312                 // resource2);
 313
 314                 // Csar csar = parserTocsarObject(csarUUID);
 315                 // validateCsarVsResourceObj(csar, resource);
 316                 // csar.node_types();
 317
 318         }
 319
 320         @Test // (enabled = false)
 321         public void UpdateCsarCertifiedVfWithSameCsar() throws Exception {
 322
 323                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 324                 RestResponse copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar",
 325                                 "VF_RI2_G4_withArtifacts.csar");
 326                 BaseRestUtils.checkSuccess(copyRes);
 327                 String csarUUID = "VF_RI2_G4_withArtifacts.csar";
 328
 329                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 330                 resourceDetails.setCsarUUID(csarUUID);
 331                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 332                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
 333                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 334                 BaseRestUtils.checkCreateResponse(createResource);
 335                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 336                 Pair<Component, RestResponse> changeComponentState = AtomicOperationUtils.changeComponentState(resource,
 337                                 UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true);
 338                 resource = (Resource) changeComponentState.getLeft();
 339
 340                 resourceDetails.setName(resource.getName());
 341                 RestResponse createResource2 = ResourceRestUtils.createResource(resourceDetails,
 342                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 343                 BaseRestUtils.checkCreateResponse(createResource2);
 344                 Resource resource2 = ResponseParser.parseToObjectUsingMapper(createResource2.getResponse(), Resource.class);
 345
 346                 CsarValidationUtils.validateCsarVfArtifact(csarUUID, resource);
 347                 ToscaDefinition toscaDefinition = ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID);
 348                 CsarValidationUtils.validateToscaDefinitonObjectVsResource(toscaDefinition, resource);
 349
 350                 // CsarValidationUtils.validateCsarVfArtifact(csarUUID2, resource2);
 351                 // ToscaDefinition toscaDefinition2 =
 352                 // ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID2);
 353                 // CsarValidationUtils.validateToscaDefinitonObjectVsResource(toscaDefinition2,
 354                 // resource2);
 355
 356                 // Csar csar = parserTocsarObject(csarUUID);
 357                 // validateCsarVsResourceObj(csar, resource);
 358                 // csar.node_types();
 359
 360         }
 361
 362         @Test // (enabled = false)
 363         public void UpdateCsarDifferentTosca() throws Exception {
 364
 365                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 366                 RestResponse copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar",
 367                                 "VF_RI2_G4_withArtifacts.csar");
 368                 BaseRestUtils.checkSuccess(copyRes);
 369                 String csarUUID = "VF_RI2_G4_withArtifacts.csar";
 370
 371                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 372                 resourceDetails.setCsarUUID(csarUUID);
 373                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 374                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
 375                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 376                 BaseRestUtils.checkCreateResponse(createResource);
 377                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 378
 379                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifactsUpdated.csar",
 380                                 "VF_RI2_G4_withArtifacts.csar");
 381                 BaseRestUtils.checkSuccess(copyRes);
 382
 383                 resourceDetails.setName(resource.getName());
 384                 RestResponse createResource2 = ResourceRestUtils.createResource(resourceDetails,
 385                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 386                 BaseRestUtils.checkCreateResponse(createResource2);
 387                 Resource resource2 = ResponseParser.parseToObjectUsingMapper(createResource2.getResponse(), Resource.class);
 388
 389                 CsarValidationUtils.validateCsarVfArtifact(csarUUID, resource);
 390                 ToscaDefinition toscaDefinition = ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID);
 391                 CsarValidationUtils.validateToscaDefinitonObjectVsResource(toscaDefinition, resource);
 392
 393                 // CsarValidationUtils.validateCsarVfArtifact(csarUUID2, resource2);
 394                 // ToscaDefinition toscaDefinition2 =
 395                 // ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID2);
 396                 // CsarValidationUtils.validateToscaDefinitonObjectVsResource(toscaDefinition2,
 397                 // resource2);
 398
 399                 // Csar csar = parserTocsarObject(csarUUID);
 400                 // validateCsarVsResourceObj(csar, resource);
 401                 // csar.node_types();
 402
 403         }
 404
 405         @Test // (enabled = false)
 406         public void UpdateCsarDifferentToscaAndArtifacts() throws Exception {
 407
 408                 User sdncModifierDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 409                 RestResponse copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_a.csar",
 410                                 "VF_RI2_G4_withArtifacts.csar");
 411                 BaseRestUtils.checkSuccess(copyRes);
 412                 String csarUUID = "VF_RI2_G4_withArtifacts.csar";
 413
 414                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 415                 resourceDetails.setCsarUUID(csarUUID);
 416                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 417                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
 418                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 419                 BaseRestUtils.checkCreateResponse(createResource);
 420                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 421
 422                 copyRes = copyCsarRest(sdncModifierDetails, "VF_RI2_G4_withArtifacts_UpdateToscaAndArtifacts.csar",
 423                                 "VF_RI2_G4_withArtifacts.csar");
 424                 BaseRestUtils.checkSuccess(copyRes);
 425
 426                 resourceDetails.setName(resource.getName());
 427                 RestResponse createResource2 = ResourceRestUtils.createResource(resourceDetails,
 428                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 429                 BaseRestUtils.checkCreateResponse(createResource2);
 430                 Resource resource2 = ResponseParser.parseToObjectUsingMapper(createResource2.getResponse(), Resource.class);
 431
 432                 CsarValidationUtils.validateCsarVfArtifact(csarUUID, resource);
 433                 ToscaDefinition toscaDefinition = ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID);
 434                 CsarValidationUtils.validateToscaDefinitonObjectVsResource(toscaDefinition, resource);
 435
 436                 // CsarValidationUtils.validateCsarVfArtifact(csarUUID2, resource2);
 437                 // ToscaDefinition toscaDefinition2 =
 438                 // ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID2);
 439                 // CsarValidationUtils.validateToscaDefinitonObjectVsResource(toscaDefinition2,
 440                 // resource2);
 441
 442                 // Csar csar = parserTocsarObject(csarUUID);
 443                 // validateCsarVsResourceObj(csar, resource);
 444                 // csar.node_types();
 445
 446         }
 447
 448         @Test // (enabled = false)
 449         public void migration() throws Exception {
 450                 String csarUUID = "VF_RI2_G4_withArtifacts";
 451                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
 452                 resourceDetails.setCsarUUID(csarUUID);
 453                 resourceDetails.setName("Resource1");
 454                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 455                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
 456                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 457                 BaseRestUtils.checkCreateResponse(createResource);
 458
 459                 resourceDetails.setName("Resource2");
 460                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 461                 createResource = ResourceRestUtils.createResource(resourceDetails,
 462                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 463                 BaseRestUtils.checkCreateResponse(createResource);
 464                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 465                 resource = (Resource) AtomicOperationUtils
 466                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 467                 resource = (Resource) AtomicOperationUtils
 468                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 469                 resource = (Resource) AtomicOperationUtils
 470                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 471                 resource = (Resource) AtomicOperationUtils
 472                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 473
 474                 resourceDetails.setName("Resource3");
 475                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 476                 createResource = ResourceRestUtils.createResource(resourceDetails,
 477                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 478                 BaseRestUtils.checkCreateResponse(createResource);
 479                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 480                 resource = (Resource) AtomicOperationUtils
 481                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 482                 resource = (Resource) AtomicOperationUtils
 483                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 484                 resource = (Resource) AtomicOperationUtils
 485                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 486
 487                 resourceDetails.setName("Resource4");
 488                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 489                 createResource = ResourceRestUtils.createResource(resourceDetails,
 490                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 491                 BaseRestUtils.checkCreateResponse(createResource);
 492                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 493                 resource = (Resource) AtomicOperationUtils
 494                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 495                 resource = (Resource) AtomicOperationUtils
 496                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 497                 resource = (Resource) AtomicOperationUtils
 498                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 499                 resource = (Resource) AtomicOperationUtils
 500                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 501                 resource = (Resource) AtomicOperationUtils
 502                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 503
 504                 resourceDetails.setName("Resource5");
 505                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 506                 createResource = ResourceRestUtils.createResource(resourceDetails,
 507                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 508                 BaseRestUtils.checkCreateResponse(createResource);
 509                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 510                 resource = (Resource) AtomicOperationUtils
 511                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 512                 resource = (Resource) AtomicOperationUtils
 513                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 514                 resource = (Resource) AtomicOperationUtils
 515                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 516                 resource = (Resource) AtomicOperationUtils
 517                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 518
 519                 resourceDetails.setName("Resource6");
 520                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 521                 createResource = ResourceRestUtils.createResource(resourceDetails,
 522                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 523                 BaseRestUtils.checkCreateResponse(createResource);
 524                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 525                 resource = (Resource) AtomicOperationUtils
 526                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.STARTCERTIFICATION, true)
 527                                 .getLeft();
 528
 529                 resourceDetails.setName("Resource7");
 530                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 531                 createResource = ResourceRestUtils.createResource(resourceDetails,
 532                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 533                 BaseRestUtils.checkCreateResponse(createResource);
 534                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 535                 resource = (Resource) AtomicOperationUtils
 536                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 537                 resource = (Resource) AtomicOperationUtils
 538                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFICATIONREQUEST, true)
 539                                 .getLeft();
 540
 541                 logger.debug("7 VF resources were created");
 542
 543         }
 544
 545         public static RestResponse copyCsarRest(User sdncModifierDetails, String sourceCsarUuid, String targetCsarUuid)
 546                         throws Exception {
 547
 548                 Config config = Utils.getConfig();
 549                 String url = String.format(Urls.COPY_CSAR_USING_SIMULATOR, config.getCatalogBeHost(), config.getCatalogBePort(),
 550                                 sourceCsarUuid, targetCsarUuid);
 551                 String userId = sdncModifierDetails.getUserId();
 552                 Map<String, String> headersMap = prepareHeadersMap(userId);
 553                 HttpRequest http = new HttpRequest();
 554
 555                 RestResponse copyCsarResponse = http.httpSendPost(url, "dummy", headersMap);
 556                 if (copyCsarResponse.getErrorCode() != 200) {
 557                         return null;
 558                 }
 559                 return copyCsarResponse;
 560
 561         }
 562
 563         private static Map<String, String> prepareHeadersMap(String userId) {
 564                 Map<String, String> headersMap = new HashMap<String, String>();
 565                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), "application/json");
 566                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), "application/json");
 567                 if (userId != null) {
 568                         headersMap.put(HttpHeaderEnum.USER_ID.getValue(), userId);
 569                 }
 570                 return headersMap;
 571         }
 572
 573         public static void main(String[] args) throws Exception {
 574                 // String csarUUID = "VF_RI2_G4_withArtifacts";
 575                 String csarUUID = "node_types";
 576                 ToscaParserUtils.getToscaDefinitionObjectByCsarUuid(csarUUID);
 577         }
 578 }