gerrit.onap Code Review - sdc.git/blob

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