test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/artifacts/PlaceHolderValidations.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.artifacts;
  22
  23 //import static org.junit.Assert.assertTrue;
  24
  25 import fj.data.Either;
  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.enums.ResourceTypeEnum;
  30 import org.openecomp.sdc.be.model.*;
  31 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  32 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  33 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  34 import org.openecomp.sdc.ci.tests.datatypes.enums.*;
  35 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  36 import org.openecomp.sdc.ci.tests.utils.Utils;
  37 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  38 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  39 import org.openecomp.sdc.ci.tests.utils.general.FileUtils;
  40 import org.openecomp.sdc.ci.tests.utils.rest.*;
  41 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  42 import org.slf4j.Logger;
  43 import org.slf4j.LoggerFactory;
  44 import org.testng.annotations.BeforeMethod;
  45 import org.testng.annotations.Test;
  46
  47 import java.io.File;
  48 import java.io.FileNotFoundException;
  49 import java.io.IOException;
  50 import java.util.ArrayList;
  51 import java.util.Arrays;
  52 import java.util.List;
  53 import java.util.Map;
  54
  55 import static org.testng.AssertJUnit.*;
  56
  57 public class PlaceHolderValidations extends ComponentBaseTest {
  58         private static Logger logger = LoggerFactory.getLogger(PlaceHolderValidations.class.getName());
  59         private static final String heatExtension = "yaml";
  60         // private static final String yangXmlExtension = "xml";
  61         // private static final String muranoPkgExtension = "zip";
  62         private final String folderName = "addHeatArtifactToServiceAndSertify";
  63         private Resource resource;
  64         private final int timeOut = 60;
  65         private ArtifactReqDetails updateArtifactReqDetails = null;
  66         protected User sdncDesignerDetails1 = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  67         protected User sdncDesignerDetails2 = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2);
  68         protected ResourceReqDetails resourceDetails1;
  69         protected ResourceReqDetails resourceVF;
  70         protected ResourceReqDetails resourceCP;
  71         protected ResourceReqDetails resourceVL;
  72
  73         protected ArtifactReqDetails heatArtifactDetails;
  74         protected ArtifactReqDetails heatVolArtifactDetails;
  75         protected ArtifactReqDetails heatNetArtifactDetails;
  76
  77         public PlaceHolderValidations() {
  78                 super(name, PlaceHolderValidations.class.getName());
  79         }
  80
  81         @Rule
  82         public static TestName name = new TestName();
  83
  84         @BeforeMethod
  85         public void init() throws IOException, Exception {
  86
  87                 heatArtifactDetails = ElementFactory.getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
  88                 heatNetArtifactDetails = ElementFactory
  89                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT_NET.getType());
  90                 heatVolArtifactDetails = ElementFactory
  91                                 .getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT_VOL.getType());
  92                 Resource resourceObject = AtomicOperationUtils
  93                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
  94                 resourceDetails1 = new ResourceReqDetails(resourceObject);
  95                 resourceObject = AtomicOperationUtils.createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true)
  96                                 .left().value();
  97                 resourceVF = new ResourceReqDetails(resourceObject);
  98                 resourceObject = AtomicOperationUtils.createResourceByType(ResourceTypeEnum.CP, UserRoleEnum.DESIGNER, true)
  99                                 .left().value();
 100                 resourceCP = new ResourceReqDetails(resourceObject);
 101                 resourceObject = AtomicOperationUtils.createResourceByType(ResourceTypeEnum.VL, UserRoleEnum.DESIGNER, true)
 102                                 .left().value();
 103                 resourceVL = new ResourceReqDetails(resourceObject);
 104         }
 105
 106         @Test
 107         public void validateDeploymentPlaceHoldersByConfig() throws IOException {
 108                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails1, sdncDesignerDetails1);
 109                 Resource resourceObject = ResponseParser.convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 110                 Map<String, ArtifactDefinition> deploymentArtifacts = resourceObject.getDeploymentArtifacts();
 111                 assertNotNull("deploymentArtifacts list is null", deploymentArtifacts);
 112                 List<String> listOfResDepArtTypesFromConfig = Utils.getListOfDepResArtLabels(true);
 113                 assertNotNull("deployment artifact types list is null", listOfResDepArtTypesFromConfig);
 114                 for (String resDepArtType : listOfResDepArtTypesFromConfig) {
 115                         assertNotNull("placeholder of " + resDepArtType + " type doesn't exist",
 116                                         deploymentArtifacts.get(resDepArtType));
 117                 }
 118         }
 119
 120         /*private void validateToscaArtifactsBeforeAndAfterSFT(ResourceReqDetails resourceDetails)
 121                         throws IOException, Exception {
 122                 RestResponse componentResponse = ResourceRestUtils.getResource(resourceDetails, sdncDesignerDetails1);
 123                 Component component = ResponseParser.convertResourceResponseToJavaObject(componentResponse.getResponse());
 124                 Map<String, ArtifactDefinition> toscaArtifacts = component.getToscaArtifacts();
 125                 for (ArtifactDefinition artifact : toscaArtifacts.values()) {
 126                         assertNull(artifact.getEsId());
 127                 }
 128
 129                 componentResponse = LifecycleRestUtils.changeResourceState(resourceDetails, sdncDesignerDetails1,
 130                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 131                 component = ResponseParser.convertResourceResponseToJavaObject(componentResponse.getResponse());
 132                 toscaArtifacts = component.getToscaArtifacts();
 133
 134                 for (ArtifactDefinition artifact : toscaArtifacts.values()) {
 135                         assertEquals(artifact.getEsId(), artifact.getUniqueId());
 136                         List<Pair<String, String>> fields = new ArrayList();
 137                         fields.add(new Pair<String, String>("id", artifact.getEsId()));
 138                         List<Row> fetchFromTable = CassandraUtils.fetchFromTableQuery("sdcartifact", "resources", fields);
 139                         assertTrue(1 == fetchFromTable.size());
 140                 }
 141         }*/
 142
 143         /*@Test
 144         public void validateToscaArtifactsBeforeAndAfterSFT() throws IOException, Exception {
 145                 // TODO ADD VF and Service
 146                 validateToscaArtifactsBeforeAndAfterSFT(resourceDetails1);
 147                 validateToscaArtifactsBeforeAndAfterSFT(resourceCP);
 148                 validateToscaArtifactsBeforeAndAfterSFT(resourceVL);
 149         }*/
 150
 151         @Test
 152         public void validateToscaPlaceHoldersByConfig() throws IOException, Exception {
 153                 List<Component> components = new ArrayList<>();
 154                 RestResponse componentGetResponse = ResourceRestUtils.getResource(resourceDetails1, sdncDesignerDetails1);
 155                 components.add(ResponseParser.convertResourceResponseToJavaObject(componentGetResponse.getResponse()));
 156
 157                 componentGetResponse = ResourceRestUtils.getResource(resourceCP, sdncDesignerDetails1);
 158                 components.add(ResponseParser.convertResourceResponseToJavaObject(componentGetResponse.getResponse()));
 159
 160                 componentGetResponse = ResourceRestUtils.getResource(resourceVF, sdncDesignerDetails1);
 161                 components.add(ResponseParser.convertResourceResponseToJavaObject(componentGetResponse.getResponse()));
 162
 163                 componentGetResponse = ResourceRestUtils.getResource(resourceVL, sdncDesignerDetails1);
 164                 components.add(ResponseParser.convertResourceResponseToJavaObject(componentGetResponse.getResponse()));
 165
 166                 Service service = AtomicOperationUtils
 167                                 .createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true).left().value();
 168                 componentGetResponse = ServiceRestUtils.getService(service.getUniqueId(),
 169                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 170                 components.add(ResponseParser.parseToObjectUsingMapper(componentGetResponse.getResponse(), Service.class));
 171
 172                 for (Component component : components) {
 173                         Map<String, ArtifactDefinition> toscaArtifacts = component.getToscaArtifacts();
 174                         assertNotNull("toscaArtifacts list is null", toscaArtifacts);
 175                         List<String> listOfToscaArtTypesFromConfig = Utils.getListOfToscaArtLabels(true);
 176                         assertNotNull("tosca artifact types list is null", listOfToscaArtTypesFromConfig);
 177                         for (String toscaArtType : listOfToscaArtTypesFromConfig) {
 178                                 assertNotNull("placeholder of " + toscaArtType + " type doesn't exist",
 179                                                 toscaArtifacts.get(toscaArtType));
 180                         }
 181                 }
 182
 183         }
 184
 185         // test check configuration of "displayName" field for "heat" type
 186         // deployment artifact
 187         @Test
 188         public void validateDeploymentPlaceHoldersDescriptionOfHeatByConfig() throws IOException {
 189
 190                 Map<String, Object> mapOfDepResArtTypesObjects = getMapOfDepResArtTypesObjects();
 191                 assertNotNull("deployment artifact types list is null", mapOfDepResArtTypesObjects);
 192                 Object object = mapOfDepResArtTypesObjects.get("heat");
 193                 if (object instanceof Map<?, ?>) {
 194                         Map<String, Object> map = (Map<String, Object>) object;
 195                         assertTrue(map.get("displayName").equals("Base HEAT Template"));
 196                 } else {
 197                         assertTrue("return object does not instance of map", false);
 198                 }
 199         }
 200
 201         @Test
 202         public void addDepResArtEachType() throws Exception {
 203
 204                 String artType;
 205
 206                 addDeploymentArtifactByTypeToResource(resourceDetails1, heatArtifactDetails);
 207                 addDeploymentArtifactByTypeToResource(resourceDetails1, heatVolArtifactDetails);
 208                 addDeploymentArtifactByTypeToResource(resourceDetails1, heatNetArtifactDetails);
 209                 RestResponse response = ResourceRestUtils.getResource(resourceDetails1.getUniqueId());
 210                 resource = ResponseParser.convertResourceResponseToJavaObject(response.getResponse());
 211                 List<String> listOfResDepArtTypesFromConfig = Utils.getListOfDepResArtLabels(true);
 212                 assertNotNull("deployment artifact types list is null", listOfResDepArtTypesFromConfig);
 213                 for (String iter : listOfResDepArtTypesFromConfig) {
 214                         artType = iter;
 215                         verifyDepArtPlaceHoldersByType(artType);
 216                 }
 217         }
 218
 219         @Test
 220         public void checkHeatParametersExistingForEachType() throws Exception {
 221
 222                 String artType;
 223
 224                 addDeploymentArtifactByTypeToResource(resourceDetails1, heatArtifactDetails);
 225                 addDeploymentArtifactByTypeToResource(resourceDetails1, heatVolArtifactDetails);
 226                 addDeploymentArtifactByTypeToResource(resourceDetails1, heatNetArtifactDetails);
 227                 RestResponse response = ResourceRestUtils.getResource(resourceDetails1.getUniqueId());
 228                 resource = ResponseParser.convertResourceResponseToJavaObject(response.getResponse());
 229                 List<String> listOfResDepArtTypesFromConfig = Utils.getListOfDepResArtLabels(true);
 230                 assertNotNull("deployment artifact types list is null", listOfResDepArtTypesFromConfig);
 231                 for (String iter : listOfResDepArtTypesFromConfig) {
 232                         artType = iter;
 233                         verifyDepArtPlaceHoldersByType(artType);
 234                         verifyHeatParametersExistance(artType, false);
 235                 }
 236         }
 237
 238         @Test
 239         public void checkHeatParametersExistingForSpecificType() throws Exception {
 240
 241                 String artType;
 242
 243                 addDeploymentArtifactByTypeToResource(resourceDetails1, heatVolArtifactDetails);
 244                 addDeploymentArtifactByTypeToResource(resourceDetails1, heatNetArtifactDetails);
 245                 RestResponse response = ResourceRestUtils.getResource(resourceDetails1.getUniqueId());
 246                 resource = ResponseParser.convertResourceResponseToJavaObject(response.getResponse());
 247                 List<String> listOfResDepArtTypesFromConfig = Utils.getListOfDepResArtLabels(true);
 248                 assertNotNull("deployment artifact types list is null", listOfResDepArtTypesFromConfig);
 249                 for (String iter : listOfResDepArtTypesFromConfig) {
 250                         artType = iter;
 251                         if (heatArtifactDetails.getArtifactLabel().equals(iter)) {
 252                                 verifyHeatParametersExistance(artType, true);
 253                         } else {
 254                                 verifyHeatParametersExistance(artType, false);
 255                         }
 256                 }
 257         }
 258
 259         @Test
 260         public void addAndDeleteDepResArtEachType() throws Exception {
 261
 262                 String artType;
 263
 264                 addDeploymentArtifactByTypeToResource(resourceDetails1, heatArtifactDetails);
 265                 addDeploymentArtifactByTypeToResource(resourceDetails1, heatVolArtifactDetails);
 266                 addDeploymentArtifactByTypeToResource(resourceDetails1, heatNetArtifactDetails);
 267                 RestResponse response = ResourceRestUtils.getResource(resourceDetails1.getUniqueId());
 268                 resource = ResponseParser.convertResourceResponseToJavaObject(response.getResponse());
 269                 List<String> listOfResDepArtTypesFromConfig = Utils.getListOfDepResArtLabels(true);
 270                 assertNotNull("deployment artifact types list is null", listOfResDepArtTypesFromConfig);
 271                 for (String iter : listOfResDepArtTypesFromConfig) {
 272                         artType = iter;
 273                         verifyDepArtPlaceHoldersByType(artType);
 274                 }
 275                 RestResponse restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails1,
 276                                 sdncDesignerDetails1, LifeCycleStatesEnum.CHECKIN);
 277                 assertTrue("expected response code in CHECKIN 200", restResponseResource.getErrorCode() == 200);
 278                 restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails1, sdncDesignerDetails1,
 279                                 LifeCycleStatesEnum.CHECKOUT);
 280                 assertTrue("expected response code in CHECKOUT 200", restResponseResource.getErrorCode() == 200);
 281
 282                 // delete all deployment artifacts
 283                 deleteDeploymentArtifactByTypeToResource(resourceDetails1, heatArtifactDetails);
 284                 deleteDeploymentArtifactByTypeToResource(resourceDetails1, heatVolArtifactDetails);
 285                 deleteDeploymentArtifactByTypeToResource(resourceDetails1, heatNetArtifactDetails);
 286                 response = ResourceRestUtils.getResource(resourceDetails1.getUniqueId());
 287                 resource = ResponseParser.convertResourceResponseToJavaObject(response.getResponse());
 288                 listOfResDepArtTypesFromConfig = Utils.getListOfDepResArtLabels(true);
 289                 assertNotNull("deployment artifact types list is null", listOfResDepArtTypesFromConfig);
 290                 for (String iter : listOfResDepArtTypesFromConfig) {
 291                         artType = iter;
 292                         verifyDepArtPlaceHoldersByType(artType);
 293                 }
 294         }
 295
 296         @Test
 297         public void addRemoveAddAgainArtifact() throws Exception {
 298
 299                 // get MAP before upload artifact
 300                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails1, sdncDesignerDetails1);
 301                 Resource resourceRespJavaObject = ResponseParser
 302                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 303                 Map<String, ArtifactDefinition> deploymentArtifacts = resourceRespJavaObject.getDeploymentArtifacts();
 304
 305                 ArtifactDefinition artifactDefinition = deploymentArtifacts.get("heat");
 306
 307                 // validate place holder exist
 308                 assertNotNull(artifactDefinition);
 309
 310                 // add artifact
 311                 updateArtifactReqDetails = getUpdateArtifactDetails(ArtifactTypeEnum.HEAT.getType());
 312
 313                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.updateInformationalArtifactToResource(
 314                                 updateArtifactReqDetails, sdncDesignerDetails1, resourceDetails1.getUniqueId());
 315                 logger.debug("addInformationalArtifactToResource response:  "
 316                                 + addInformationalArtifactToResource.getResponseMessage());
 317                 assertTrue("response code is not 200, returned :" + addInformationalArtifactToResource.getErrorCode(),
 318                                 addInformationalArtifactToResource.getErrorCode() == 200);
 319
 320                 ArtifactDefinition artifactDefinitionResponseJavaObject = ResponseParser
 321                                 .convertArtifactDefinitionResponseToJavaObject(addInformationalArtifactToResource.getResponse());
 322                 ArtifactDefinition artDef1 = fillArtDefFromResponse(artifactDefinitionResponseJavaObject);
 323
 324                 // remove artifact
 325                 RestResponse deleteArtifactFromResource = ArtifactRestUtils.deleteInformationalArtifactFromResource(
 326                                 resourceDetails1.getUniqueId(), updateArtifactReqDetails, sdncDesignerDetails1);
 327                 logger.debug(
 328                                 "addInformationalArtifactToResource response:  " + deleteArtifactFromResource.getResponseMessage());
 329                 assertTrue("response code is not 200, returned :" + deleteArtifactFromResource.getErrorCode(),
 330                                 deleteArtifactFromResource.getErrorCode() == 200);
 331
 332                 RestResponse getResourceResp = ResourceRestUtils.getResource(resourceDetails1, sdncDesignerDetails1);
 333
 334                 artifactDefinitionResponseJavaObject = ResponseParser
 335                                 .convertArtifactDefinitionResponseToJavaObject(deleteArtifactFromResource.getResponse());
 336                 assertTrue(artifactDefinitionResponseJavaObject.getArtifactName().isEmpty());
 337                 assertTrue(artifactDefinitionResponseJavaObject.getDescription().isEmpty());
 338                 assertTrue(artifactDefinitionResponseJavaObject.getArtifactChecksum().isEmpty());
 339                 assertTrue(artifactDefinitionResponseJavaObject.getEsId().isEmpty());
 340                 assertTrue(artifactDefinitionResponseJavaObject.getArtifactUUID().isEmpty());
 341                 assertNull(artifactDefinitionResponseJavaObject.getHeatParameters());
 342
 343                 // add artifact again with different user
 344                 addInformationalArtifactToResource = ArtifactRestUtils.updateInformationalArtifactToResource(
 345                                 heatArtifactDetails, sdncDesignerDetails1, resourceDetails1.getUniqueId());
 346                 logger.debug("addInformationalArtifactToResource response:  "
 347                                 + addInformationalArtifactToResource.getResponseMessage());
 348                 assertTrue("response code is not 200, returned :" + addInformationalArtifactToResource.getErrorCode(),
 349                                 addInformationalArtifactToResource.getErrorCode() == 200);
 350
 351                 artifactDefinitionResponseJavaObject = ResponseParser
 352                                 .convertArtifactDefinitionResponseToJavaObject(addInformationalArtifactToResource.getResponse());
 353                 ArtifactDefinition artDef2 = fillArtDefFromResponse(artifactDefinitionResponseJavaObject);
 354
 355                 assertFalse("check artifact checksum", artDef1.getArtifactChecksum().equals(artDef2.getArtifactChecksum()));
 356                 assertTrue("check artifact EsId", artDef1.getEsId().equals(artDef2.getEsId()));
 357                 assertFalse("check artifact UUID", artDef1.getArtifactUUID().equals(artDef2.getArtifactUUID()));
 358                 assertTrue("check UserIdCreator", artDef1.getUserIdCreator().equals(artDef2.getUserIdCreator()));
 359                 assertTrue("check UserIdLastUpdater", artDef1.getUserIdLastUpdater().equals(artDef2.getUserIdLastUpdater()));
 360         }
 361
 362         @Test
 363         public void addUpdateArtifactByType() throws Exception {
 364
 365                 // get MAP before upload artifact
 366                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails1, sdncDesignerDetails1);
 367                 Resource resourceRespJavaObject = ResponseParser
 368                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 369                 Map<String, ArtifactDefinition> deploymentArtifacts = resourceRespJavaObject.getDeploymentArtifacts();
 370
 371                 ArtifactDefinition artifactDefinition = deploymentArtifacts.get("heat");
 372
 373                 // validate place holder exist
 374                 assertNotNull(artifactDefinition);
 375
 376                 // add artifact
 377                 updateArtifactReqDetails = getUpdateArtifactDetails(ArtifactTypeEnum.HEAT.getType());
 378
 379                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.updateInformationalArtifactToResource(
 380                                 updateArtifactReqDetails, sdncDesignerDetails1, resourceDetails1.getUniqueId());
 381                 logger.debug("addInformationalArtifactToResource response:  "
 382                                 + addInformationalArtifactToResource.getResponseMessage());
 383                 assertTrue("response code is not 200, returned :" + addInformationalArtifactToResource.getErrorCode(),
 384                                 addInformationalArtifactToResource.getErrorCode() == 200);
 385
 386                 ArtifactDefinition artifactDefinitionResponseJavaObject = ResponseParser
 387                                 .convertArtifactDefinitionResponseToJavaObject(addInformationalArtifactToResource.getResponse());
 388                 ArtifactDefinition artDef1 = fillArtDefFromResponse(artifactDefinitionResponseJavaObject);
 389
 390                 RestResponse restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails1,
 391                                 sdncDesignerDetails1, LifeCycleStatesEnum.CHECKIN);
 392                 restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails1, sdncDesignerDetails2,
 393                                 LifeCycleStatesEnum.CHECKOUT);
 394
 395                 // update with different user artifact
 396                 heatArtifactDetails = ElementFactory.getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
 397                 heatArtifactDetails.setUniqueId(artifactDefinition.getUniqueId());
 398                 heatArtifactDetails.setArtifactName("2.yaml");
 399                 heatArtifactDetails.setArtifactLabel(artifactDefinition.getArtifactLabel());
 400
 401                 addInformationalArtifactToResource = ArtifactRestUtils.updateInformationalArtifactToResource(
 402                                 heatArtifactDetails, sdncDesignerDetails2, resourceDetails1.getUniqueId(), "heat");
 403                 logger.debug("addInformationalArtifactToResource response:  "
 404                                 + addInformationalArtifactToResource.getResponseMessage());
 405                 assertTrue("response code is not 200, returned :" + addInformationalArtifactToResource.getErrorCode(),
 406                                 addInformationalArtifactToResource.getErrorCode() == 200);
 407
 408                 artifactDefinitionResponseJavaObject = ResponseParser
 409                                 .convertArtifactDefinitionResponseToJavaObject(addInformationalArtifactToResource.getResponse());
 410                 ArtifactDefinition artDef2 = fillArtDefFromResponse(artifactDefinitionResponseJavaObject);
 411                 verifyArtDefFields(artDef1, artDef2);
 412
 413         }
 414
 415         @Test
 416         public void addUpdateDeleteArtifact() throws Exception {
 417
 418                 // get MAP before upload artifact
 419                 RestResponse resourceGetResponse = ResourceRestUtils.getResource(resourceDetails1, sdncDesignerDetails1);
 420                 Resource resourceRespJavaObject = ResponseParser
 421                                 .convertResourceResponseToJavaObject(resourceGetResponse.getResponse());
 422                 Map<String, ArtifactDefinition> deploymentArtifacts = resourceRespJavaObject.getDeploymentArtifacts();
 423
 424                 ArtifactDefinition artifactDefinition = deploymentArtifacts.get("heat");
 425
 426                 // validate place holder exist
 427                 assertNotNull(artifactDefinition);
 428
 429                 updateArtifactReqDetails = getUpdateArtifactDetails(ArtifactTypeEnum.HEAT.getType());
 430
 431                 RestResponse addInformationalArtifactToResource = ArtifactRestUtils.updateInformationalArtifactToResource(
 432                                 updateArtifactReqDetails, sdncDesignerDetails1, resourceDetails1.getUniqueId());
 433                 logger.debug("addInformationalArtifactToResource response:  "
 434                                 + addInformationalArtifactToResource.getResponseMessage());
 435                 assertTrue("response code is not 200, returned :" + addInformationalArtifactToResource.getErrorCode(),
 436                                 addInformationalArtifactToResource.getErrorCode() == 200);
 437
 438                 ArtifactDefinition artifactDefinitionResponseJavaObject = ResponseParser
 439                                 .convertArtifactDefinitionResponseToJavaObject(addInformationalArtifactToResource.getResponse());
 440                 ArtifactDefinition artDef1 = fillArtDefFromResponse(artifactDefinitionResponseJavaObject);
 441
 442                 RestResponse restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails1,
 443                                 sdncDesignerDetails1, LifeCycleStatesEnum.CHECKIN);
 444                 restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails1, sdncDesignerDetails2,
 445                                 LifeCycleStatesEnum.CHECKOUT);
 446
 447                 // update with different user artifact
 448                 heatArtifactDetails = ElementFactory.getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
 449                 heatArtifactDetails.setArtifactName("2.yaml");
 450
 451                 addInformationalArtifactToResource = ArtifactRestUtils.updateInformationalArtifactToResource(
 452                                 heatArtifactDetails, sdncDesignerDetails2, resourceDetails1.getUniqueId(), "heat");
 453                 logger.debug("addInformationalArtifactToResource response:  "
 454                                 + addInformationalArtifactToResource.getResponseMessage());
 455                 assertTrue("response code is not 200, returned :" + addInformationalArtifactToResource.getErrorCode(),
 456                                 addInformationalArtifactToResource.getErrorCode() == 200);
 457
 458                 artifactDefinitionResponseJavaObject = ResponseParser
 459                                 .convertArtifactDefinitionResponseToJavaObject(addInformationalArtifactToResource.getResponse());
 460                 ArtifactDefinition artDef2 = fillArtDefFromResponse(artifactDefinitionResponseJavaObject);
 461
 462                 verifyArtDefFields(artDef1, artDef2);
 463
 464                 RestResponse delteArtifactFromResource = ArtifactRestUtils.deleteInformationalArtifactFromResource(
 465                                 resourceDetails1.getUniqueId(), heatArtifactDetails, sdncDesignerDetails2);
 466                 logger.debug("addInformationalArtifactToResource response: {}", delteArtifactFromResource.getResponseMessage());
 467                 assertTrue("response code is not 200, returned :" + delteArtifactFromResource.getErrorCode(),
 468                                 delteArtifactFromResource.getErrorCode() == 200);
 469
 470         }
 471
 472         @Test
 473         public void addHeatVolArtInvalidExtension() throws Exception {
 474
 475                 heatVolArtifactDetails.setArtifactName("heatVol.txt");
 476                 RestResponse response = getResponseOnAddDeploymentArtifactByTypeToResource(resourceDetails1,
 477                                 heatVolArtifactDetails);
 478                 ErrorInfo errorInfo = ErrorValidationUtils
 479                                 .parseErrorConfigYaml(ActionStatus.WRONG_ARTIFACT_FILE_EXTENSION.name());
 480                 assertEquals("Check response code after upload artifact", errorInfo.getCode(), response.getErrorCode());
 481                 List<String> variables = Arrays.asList(ArtifactTypeEnum.HEAT_VOL.getType());
 482                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.WRONG_ARTIFACT_FILE_EXTENSION.name(), variables,
 483                                 response.getResponse());
 484         }
 485
 486         @Test
 487         public void addHeatNetArtInvalidExtension() throws Exception {
 488
 489                 heatNetArtifactDetails.setArtifactName("yaml");
 490                 RestResponse response = getResponseOnAddDeploymentArtifactByTypeToResource(resourceDetails1,
 491                                 heatNetArtifactDetails);
 492                 ErrorInfo errorInfo = ErrorValidationUtils
 493                                 .parseErrorConfigYaml(ActionStatus.WRONG_ARTIFACT_FILE_EXTENSION.name());
 494                 assertEquals("Check response code after upload artifact", errorInfo.getCode(), response.getErrorCode());
 495                 List<String> variables = Arrays.asList(ArtifactTypeEnum.HEAT_NET.getType());
 496                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.WRONG_ARTIFACT_FILE_EXTENSION.name(), variables,
 497                                 response.getResponse());
 498         }
 499
 500         @Test
 501         public void checkServiceSecurityTemplateInformationalArtifactsCreation() throws IOException, Exception {
 502
 503                 Either<Service, RestResponse> createServiceResponse = AtomicOperationUtils
 504                                 .createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true);
 505                 Map<String, ArtifactDefinition> artifacts = null;
 506                 ArtifactDefinition securitytemplate = null;
 507                 if (createServiceResponse.isLeft()) {
 508                         Component component = createServiceResponse.left().value();
 509                         artifacts = component.getArtifacts();
 510                         securitytemplate = artifacts.get("servicesecuritytemplate");
 511                         assertNotNull(securitytemplate);
 512                         assertEquals("Service Security Template", securitytemplate.getArtifactDisplayName());
 513                 } else {
 514                         logger.debug("checkSecurityTemplateInformationalArtifactsCreation service creation response:  "
 515                                         + createServiceResponse.right().value().getResponseMessage());
 516                 }
 517         }
 518
 519         @Test
 520         public void checkResourceSecurityTemplateInformationalArtifactsCreation() throws IOException, Exception {
 521
 522                 Resource resource = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VFC,
 523                                 NormativeTypesEnum.CONTAINER_APPLICATION, ResourceCategoryEnum.APPLICATION_L4_BORDER,
 524                                 UserRoleEnum.DESIGNER, true).left().value();
 525                 Map<String, ArtifactDefinition> artifacts = resource.getArtifacts();
 526                 ArtifactDefinition securitytemplate = artifacts.get("resourcesecuritytemplate");
 527                 assertNotNull(securitytemplate);
 528                 assertEquals("Resource Security Template", securitytemplate.getArtifactDisplayName());
 529         }
 530
 531         // Benny
 532         @Test
 533         public void serviceSecurityTemplateInformationalArtifact() throws IOException, Exception {
 534                 String artifactPlaceHolder = "servicesecuritytemplate";
 535                 Service service = AtomicOperationUtils
 536                                 .createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true).left().value();
 537                 Map<String, ArtifactDefinition> artifacts = service.getArtifacts();
 538                 ArtifactDefinition securitytemplate = artifacts.get(artifactPlaceHolder);
 539                 assertNotNull(securitytemplate);
 540                 assertEquals("Service Security Template", securitytemplate.getArtifactDisplayName());
 541                 assertEquals("OTHER", securitytemplate.getArtifactType());
 542                 assertEquals(artifactPlaceHolder, securitytemplate.getArtifactLabel());
 543                 // Get service
 544                 RestResponse getService = ServiceRestUtils.getService(service.getUniqueId(),
 545                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 546                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, getService.getErrorCode().intValue());
 547                 service = ResponseParser.parseToObjectUsingMapper(getService.getResponse(), Service.class);
 548                 artifacts = service.getArtifacts();
 549                 securitytemplate = artifacts.get(artifactPlaceHolder);
 550                 assertNotNull(securitytemplate);
 551                 assertEquals("Service Security Template", securitytemplate.getArtifactDisplayName());
 552                 assertEquals("OTHER", securitytemplate.getArtifactType());
 553                 assertEquals(artifactPlaceHolder, securitytemplate.getArtifactLabel());
 554         }
 555
 556         @Test
 557         public void resourceSecurityTemplateInformationalArtifacts() throws IOException, Exception {
 558                 String artifactPlaceHolder = "resourcesecuritytemplate";
 559                 Resource resource = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VFC,
 560                                 NormativeTypesEnum.CONTAINER_APPLICATION, ResourceCategoryEnum.APPLICATION_L4_BORDER,
 561                                 UserRoleEnum.DESIGNER, true).left().value();
 562                 Map<String, ArtifactDefinition> artifacts = resource.getArtifacts();
 563                 ArtifactDefinition securitytemplate = artifacts.get("resourcesecuritytemplate");
 564                 assertNotNull(securitytemplate);
 565                 assertEquals("Resource Security Template", securitytemplate.getArtifactDisplayName());
 566                 assertEquals("OTHER", securitytemplate.getArtifactType());
 567                 assertEquals(artifactPlaceHolder, securitytemplate.getArtifactLabel());
 568                 // Get resource
 569                 RestResponse getresource = ResourceRestUtils.getResource(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER),
 570                                 resource.getUniqueId());
 571                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, getresource.getErrorCode().intValue());
 572                 resource = ResponseParser.parseToObjectUsingMapper(getresource.getResponse(), Resource.class);
 573                 artifacts = resource.getArtifacts();
 574                 securitytemplate = artifacts.get(artifactPlaceHolder);
 575                 assertNotNull(securitytemplate);
 576                 assertEquals("Resource Security Template", securitytemplate.getArtifactDisplayName());
 577                 assertEquals("OTHER", securitytemplate.getArtifactType());
 578                 assertEquals(artifactPlaceHolder, securitytemplate.getArtifactLabel());
 579         }
 580
 581         // ================================================
 582
 583         @SuppressWarnings("unchecked")
 584         private Map<String, Object> getMapOfDepResArtTypesObjects() throws FileNotFoundException {
 585
 586                 return (Map<String, Object>) Utils.parseYamlConfig("deploymentResourceArtifacts");
 587
 588         }
 589
 590         private void addDeploymentArtifactByTypeToResource(ResourceReqDetails resourceReqDetails,
 591                         ArtifactReqDetails artReqDetails) throws IOException, Exception {
 592
 593                 RestResponse response = ArtifactRestUtils.addInformationalArtifactToResource(artReqDetails,
 594                                 sdncDesignerDetails1, resourceReqDetails.getUniqueId());
 595                 assertTrue("add" + artReqDetails.getArtifactLabel() + " artifact to resource request returned status:"
 596                                 + response.getErrorCode(), response.getErrorCode() == 200);
 597         }
 598
 599         private RestResponse getResponseOnAddDeploymentArtifactByTypeToResource(ResourceReqDetails resourceReqDetails,
 600                         ArtifactReqDetails artReqDetails) throws IOException, Exception {
 601
 602                 return ArtifactRestUtils.addInformationalArtifactToResource(artReqDetails, sdncDesignerDetails1,
 603                                 resourceReqDetails.getUniqueId());
 604         }
 605
 606         private void deleteDeploymentArtifactByTypeToResource(ResourceReqDetails resourceReqDetails,
 607                         ArtifactReqDetails artReqDetails) throws IOException, Exception {
 608
 609                 RestResponse response = ArtifactRestUtils.deleteInformationalArtifactFromResource(
 610                                 resourceReqDetails.getUniqueId(), artReqDetails, sdncDesignerDetails1);
 611                 assertTrue("delete" + artReqDetails.getArtifactLabel() + " artifact to resource request returned status:"
 612                                 + response.getErrorCode(), response.getErrorCode() == 200);
 613         }
 614
 615         private void verifyDepArtPlaceHoldersByType(String artType) {
 616
 617                 Map<String, ArtifactDefinition> deploymentArtifacts = resource.getDeploymentArtifacts();
 618                 assertNotNull("deployment artifact data is null", deploymentArtifacts.get(artType));
 619                 assertNotNull("deployment artifact data is null", deploymentArtifacts.get(artType).getEsId());
 620                 assertNotNull("deployment artifact data is null", deploymentArtifacts.get(artType).getDescription());
 621                 assertTrue(
 622                                 "deployment artifact timeout does not equal to default value " + timeOut + " expected " + timeOut
 623                                                 + ", actual - " + deploymentArtifacts.get(artType).getTimeout(),
 624                                 deploymentArtifacts.get(artType).getTimeout() == timeOut);
 625                 assertTrue("deployment artifact label value ",
 626                                 deploymentArtifacts.get(artType).getArtifactLabel().equals(artType));
 627         }
 628
 629         private void verifyHeatParametersExistance(String artType, Boolean isNull) {
 630                 Map<String, ArtifactDefinition> deploymentArtifacts = resource.getDeploymentArtifacts();
 631                 if (isNull) {
 632                         assertNull("heatParameters list for type " + artType + " is not null",
 633                                         deploymentArtifacts.get(artType).getHeatParameters());
 634                 } else {
 635                         assertNotNull("heatParameters list for type " + artType + " is null",
 636                                         deploymentArtifacts.get(artType).getHeatParameters());
 637                 }
 638         }
 639
 640         private void verifyArtDefFields(ArtifactDefinition artDef1, ArtifactDefinition artDef2) {
 641
 642                 assertFalse("check artifact checksum", artDef1.getArtifactChecksum().equals(artDef2.getArtifactChecksum()));
 643                 assertFalse("check artifact EsId", artDef1.getEsId().equals(artDef2.getEsId()));
 644                 assertFalse("check artifact UUID", artDef1.getArtifactUUID().equals(artDef2.getArtifactUUID()));
 645                 assertTrue("check UserIdCreator", artDef1.getUserIdCreator().equals(artDef2.getUserIdCreator()));
 646                 assertFalse("check UserIdLastUpdater", artDef1.getUserIdLastUpdater().equals(artDef2.getUserIdLastUpdater()));
 647
 648         }
 649
 650         private ArtifactDefinition fillArtDefFromResponse(ArtifactDefinition artifactDefinitionResponseJavaObject) {
 651                 ArtifactDefinition artDef = new ArtifactDefinition();
 652                 artDef.setArtifactChecksum(artifactDefinitionResponseJavaObject.getArtifactChecksum());
 653                 artDef.setEsId(artifactDefinitionResponseJavaObject.getEsId());
 654                 artDef.setArtifactUUID(artifactDefinitionResponseJavaObject.getArtifactUUID());
 655                 artDef.setUserIdCreator(artifactDefinitionResponseJavaObject.getUserIdCreator());
 656                 artDef.setUserIdLastUpdater(artifactDefinitionResponseJavaObject.getUserIdLastUpdater());
 657                 return artDef;
 658         }
 659
 660         private ArtifactReqDetails getUpdateArtifactDetails(String artType) throws IOException, Exception {
 661                 String ext = heatExtension;
 662                 String sourceDir = config.getResourceConfigDir();
 663                 String testResourcesPath = sourceDir + File.separator + folderName;
 664                 List<String> listFileName = FileUtils.getFileListFromBaseDirectoryByTestName(testResourcesPath);
 665                 logger.debug("listFileName: {}", listFileName.toString());
 666
 667                 String payload = FileUtils.loadPayloadFile(listFileName, ext, true);
 668                 ArtifactReqDetails updateArtifactReqDetails = ElementFactory.getDefaultDeploymentArtifactForType(artType);
 669                 updateArtifactReqDetails.setPayload(payload);
 670                 updateArtifactReqDetails.setArtifactName("1.yaml");
 671                 return updateArtifactReqDetails;
 672         }
 673 }