catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ArtifactOperationTest.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.be.model.operations.impl;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertTrue;
  27
  28 import fj.data.Either;
  29 import java.util.ArrayList;
  30 import java.util.HashMap;
  31 import java.util.List;
  32 import java.util.Map;
  33 import org.junit.jupiter.api.BeforeAll;
  34 import org.junit.jupiter.api.BeforeEach;
  35 import org.junit.jupiter.api.Test;
  36 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  37 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  38 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  39 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  40 import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary;
  41 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  42 import org.openecomp.sdc.be.model.ArtifactDefinition;
  43 import org.openecomp.sdc.be.model.HeatParameterDefinition;
  44 import org.openecomp.sdc.be.model.ModelTestBase;
  45 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  46 import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
  47 import org.openecomp.sdc.be.resources.data.ArtifactData;
  48 import org.openecomp.sdc.be.resources.data.HeatParameterData;
  49 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  50 import org.openecomp.sdc.be.resources.data.UniqueIdData;
  51 import org.openecomp.sdc.be.resources.data.UserData;
  52 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  53 import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
  54
  55 @SpringJUnitConfig(locations = "classpath:application-context-test.xml")
  56 public class ArtifactOperationTest extends ModelTestBase {
  57
  58     private static final String ARTIFACT_NAME = "myHeatArtifact";
  59     private static final String RESOURCE_ID = "resourceId";
  60     private static final String RESOURCE_ID_2 = "resourceId2";
  61     private static final String USER_ID = "muUserId";
  62     @javax.annotation.Resource(name = "janusgraph-generic-dao")
  63     private JanusGraphGenericDao janusGraphDao;
  64     @javax.annotation.Resource
  65     private ArtifactOperation artifactOperation;
  66
  67     @BeforeAll
  68     public static void setupBeforeClass() {
  69         ModelTestBase.init();
  70     }
  71
  72     @BeforeEach
  73     public void createUserAndCategory() {
  74         String CATEGORY_NAME = "category/mycategory";
  75         deleteAndCreateCategory(CATEGORY_NAME);
  76         deleteAndCreateUser();
  77     }
  78
  79     @Test
  80     public void testCreateDeleteArtifactWithHeatParams() {
  81         ArtifactDefinition artifactWithHeat = createResourceWithHeat();
  82
  83         List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
  84         assertNotNull(heatParameters);
  85         assertEquals(1, heatParameters.size());
  86         HeatParameterDefinition parameter = heatParameters.get(0);
  87         HeatParameterData parameterData = new HeatParameterData(parameter);
  88         Either<HeatParameterData, JanusGraphOperationStatus> parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(),
  89             parameterData.getUniqueId(), HeatParameterData.class);
  90         assertTrue(parameterNode.isLeft());
  91
  92         Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID,
  93             artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
  94         assertTrue(removeArifact.isLeft());
  95
  96         ArtifactData artifactData = new ArtifactData(artifactWithHeat);
  97         Either<ArtifactData, JanusGraphOperationStatus> artifactAfterDelete = janusGraphDao.getNode(artifactData.getUniqueIdKey(),
  98             artifactData.getUniqueId(), ArtifactData.class);
  99         assertTrue(artifactAfterDelete.isRight());
 100
 101         Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(),
 102             parameterData.getUniqueId(), HeatParameterData.class);
 103         assertTrue(parameterNodeAfterDelete.isRight());
 104
 105         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
 106     }
 107
 108     @Test
 109     public void testUpdateArtifactWithHeatParams() {
 110         ArtifactDefinition artifactWithHeat = createResourceWithHeat();
 111
 112         List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
 113         assertNotNull(heatParameters);
 114         assertEquals(1, heatParameters.size());
 115         HeatParameterDefinition parameter = heatParameters.get(0);
 116         HeatParameterData parameterData = new HeatParameterData(parameter);
 117         Either<HeatParameterData, JanusGraphOperationStatus> parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(),
 118             parameterData.getUniqueId(), HeatParameterData.class);
 119         assertTrue(parameterNode.isLeft());
 120
 121         // update to artifact without params
 122         ArtifactDefinition artifactNoParams = createArtifactDefinition();
 123         artifactNoParams.setUniqueId(artifactWithHeat.getUniqueId());
 124         artifactNoParams.setArtifactType("HEAT");
 125         artifactNoParams.setArtifactVersion("2");
 126         artifactNoParams.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 127
 128         Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(artifactNoParams, RESOURCE_ID,
 129             artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, false);
 130         assertTrue(updateArifact.isLeft());
 131
 132         ArtifactData artifactData = new ArtifactData(artifactWithHeat);
 133         Either<ArtifactData, JanusGraphOperationStatus> artifactAfterUpdate = janusGraphDao.getNode(artifactData.getUniqueIdKey(),
 134             artifactData.getUniqueId(), ArtifactData.class);
 135         assertTrue(artifactAfterUpdate.isLeft());
 136         ArtifactData artifactAfterUpdateValue = artifactAfterUpdate.left().value();
 137         assertEquals(artifactNoParams.getArtifactVersion(), artifactAfterUpdateValue.getArtifactDataDefinition()
 138             .getArtifactVersion());
 139
 140         Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(),
 141             parameterData.getUniqueId(), HeatParameterData.class);
 142         assertTrue(parameterNodeAfterDelete.isRight());
 143
 144         artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
 145         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
 146         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class);
 147     }
 148
 149     @Test
 150     public void testUpdateArtifactMetadataWithHeatParams() {
 151
 152         ArtifactDefinition artifactWithHeat = createResourceWithHeat();
 153
 154         List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
 155         assertNotNull(heatParameters);
 156         assertEquals(1, heatParameters.size());
 157         HeatParameterDefinition parameter = heatParameters.get(0);
 158         HeatParameterData parameterData = new HeatParameterData(parameter);
 159         Either<HeatParameterData, JanusGraphOperationStatus> parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(),
 160             parameterData.getUniqueId(), HeatParameterData.class);
 161         assertTrue(parameterNode.isLeft());
 162
 163         // update to artifact without params
 164         artifactWithHeat.setArtifactVersion("2");
 165         artifactWithHeat.setArtifactChecksum(null);
 166         artifactWithHeat.setPayloadData(null);
 167
 168         Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(artifactWithHeat, RESOURCE_ID,
 169             artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, false);
 170         assertTrue(updateArifact.isLeft());
 171
 172         ArtifactData artifactData = new ArtifactData(artifactWithHeat);
 173         Either<ArtifactData, JanusGraphOperationStatus> artifactAfterUpdate = janusGraphDao.getNode(artifactData.getUniqueIdKey(),
 174             artifactData.getUniqueId(), ArtifactData.class);
 175         assertTrue(artifactAfterUpdate.isLeft());
 176         ArtifactData artifactAfterUpdateValue = artifactAfterUpdate.left().value();
 177         assertEquals(artifactWithHeat.getArtifactVersion(), artifactAfterUpdateValue.getArtifactDataDefinition()
 178             .getArtifactVersion());
 179
 180         Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(),
 181             parameterData.getUniqueId(), HeatParameterData.class);
 182         assertTrue(parameterNodeAfterDelete.isLeft());
 183
 184         artifactOperation.removeArifactFromResource(RESOURCE_ID_2, artifactAfterUpdateValue.getUniqueId(), NodeTypeEnum.Resource, true, false);
 185         artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
 186         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
 187         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class);
 188     }
 189
 190     @Test
 191     public void updateHeatArtifactWithTwoResources() {
 192         ArtifactDefinition artifactWithHeat = createResourceWithHeat();
 193
 194         ResourceMetadataData resource2 = createResource(RESOURCE_ID_2);
 195         Map<String, Object> props = new HashMap<>();
 196         props.put(GraphEdgePropertiesDictionary.NAME.getProperty(), ArtifactGroupTypeEnum.DEPLOYMENT.name());
 197         Either<GraphRelation, JanusGraphOperationStatus> createRelation = janusGraphDao.createRelation(resource2, new ArtifactData(artifactWithHeat),
 198             GraphEdgeLabels.ARTIFACT_REF, props);
 199         assertTrue(createRelation.isLeft());
 200
 201         List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
 202         assertNotNull(heatParameters);
 203         assertEquals(1, heatParameters.size());
 204         HeatParameterDefinition parameter = heatParameters.get(0);
 205         HeatParameterData parameterData = new HeatParameterData(parameter);
 206         Either<HeatParameterData, JanusGraphOperationStatus> parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(),
 207             parameterData.getUniqueId(), HeatParameterData.class);
 208         assertTrue(parameterNode.isLeft());
 209
 210         ArtifactDefinition atifactToUpdate = new ArtifactDefinition(artifactWithHeat);
 211
 212         // update to artifact without params
 213         atifactToUpdate.setArtifactVersion("2");
 214         atifactToUpdate.setArtifactChecksum(null);
 215         atifactToUpdate.setPayloadData(null);
 216
 217         HeatParameterDefinition heatParamUpdate = new HeatParameterDefinition(parameter);
 218         List<HeatParameterDefinition> heatParametersUpdated = new ArrayList<>();
 219         heatParamUpdate.setCurrentValue("55");
 220         heatParametersUpdated.add(heatParamUpdate);
 221         atifactToUpdate.setListHeatParameters(heatParametersUpdated);
 222
 223         Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(atifactToUpdate, RESOURCE_ID_2,
 224             atifactToUpdate.getUniqueId(), NodeTypeEnum.Resource, false);
 225         assertTrue(updateArifact.isLeft());
 226
 227         // verify old artifact and parameter still exist
 228         ArtifactData artifactData = new ArtifactData(artifactWithHeat);
 229         Either<ArtifactData, JanusGraphOperationStatus> origArtifact = janusGraphDao.getNode(artifactData.getUniqueIdKey(),
 230             artifactData.getUniqueId(), ArtifactData.class);
 231         assertTrue(origArtifact.isLeft());
 232         ArtifactData origArtifactData = origArtifact.left().value();
 233         assertEquals(artifactWithHeat.getArtifactVersion(), origArtifactData.getArtifactDataDefinition()
 234             .getArtifactVersion());
 235
 236         Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(),
 237             parameterData.getUniqueId(), HeatParameterData.class);
 238         assertTrue(parameterNodeAfterDelete.isLeft());
 239
 240         // verify new artifact and new parameter
 241         ArtifactDefinition artifactDefinitionUpdated = updateArifact.left().value();
 242         ArtifactData artifactDataUpdated = new ArtifactData(artifactDefinitionUpdated);
 243         Either<ArtifactData, JanusGraphOperationStatus> updatedArtifact = janusGraphDao.getNode(artifactDataUpdated.getUniqueIdKey(),
 244             artifactDataUpdated.getUniqueId(), ArtifactData.class);
 245         assertTrue(updatedArtifact.isLeft());
 246         ArtifactData updatedArtifactData = updatedArtifact.left().value();
 247         assertEquals(atifactToUpdate.getArtifactVersion(), updatedArtifactData.getArtifactDataDefinition()
 248             .getArtifactVersion());
 249         assertFalse(updatedArtifactData.getUniqueId().equalsIgnoreCase(origArtifactData.getUniqueId()));
 250
 251         List<HeatParameterDefinition> heatParametersAfterUpdate = artifactDefinitionUpdated.getListHeatParameters();
 252         assertNotNull(heatParametersAfterUpdate);
 253         assertEquals(1, heatParametersAfterUpdate.size());
 254         HeatParameterDefinition UpdatedHeatParameter = heatParametersAfterUpdate.get(0);
 255         assertFalse(UpdatedHeatParameter.getUniqueId().equalsIgnoreCase(parameterData.getUniqueId()));
 256         Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterUpdate = janusGraphDao.getNode(
 257             new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(), UpdatedHeatParameter.getUniqueId(), HeatParameterData.class);
 258         assertTrue(parameterNodeAfterUpdate.isLeft());
 259
 260         // delete new artifact
 261         Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID_2,
 262             artifactDefinitionUpdated.getUniqueId(), NodeTypeEnum.Resource, true, false);
 263         assertTrue(removeArifact.isLeft());
 264
 265         // verify old artifact and parameter still exist
 266         origArtifact = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
 267         assertTrue(origArtifact.isLeft());
 268         origArtifactData = origArtifact.left().value();
 269         assertEquals(artifactWithHeat.getArtifactVersion(), origArtifactData.getArtifactDataDefinition()
 270             .getArtifactVersion());
 271
 272         parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 273         assertTrue(parameterNodeAfterDelete.isLeft());
 274
 275         // verify new artifact is deleted
 276         Either<ArtifactData, JanusGraphOperationStatus> artifactAfterDelete = janusGraphDao.getNode(artifactDataUpdated.getUniqueIdKey(),
 277             artifactDataUpdated.getUniqueId(), ArtifactData.class);
 278         assertTrue(artifactAfterDelete.isRight());
 279
 280         parameterNodeAfterDelete = janusGraphDao.getNode(new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(),
 281             new HeatParameterData(UpdatedHeatParameter).getUniqueId(), HeatParameterData.class);
 282         assertTrue(parameterNodeAfterDelete.isRight());
 283
 284         artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
 285         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
 286         janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class);
 287     }
 288
 289     private ArtifactDefinition createResourceWithHeat() {
 290         createResource(RESOURCE_ID);
 291         ArtifactDefinition artifactDefinition = createArtifactDefinition();
 292         artifactDefinition.setArtifactType("HEAT");
 293         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 294
 295         List<HeatParameterDefinition> heatParams = new ArrayList<>();
 296         HeatParameterDefinition heatParam = new HeatParameterDefinition();
 297         heatParam.setCurrentValue("11");
 298         heatParam.setDefaultValue("22");
 299         heatParam.setDescription("desc");
 300         heatParam.setName("myParam");
 301         heatParam.setType("number");
 302         heatParams.add(heatParam);
 303         artifactDefinition.setListHeatParameters(heatParams);
 304
 305         Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation.addArifactToComponent(artifactDefinition, RESOURCE_ID,
 306             NodeTypeEnum.Resource, true, false);
 307         assertTrue(artifact.isLeft());
 308         return artifact.left().value();
 309     }
 310
 311     private ArtifactDefinition createArtifactDefinition() {
 312         ArtifactDefinition artifactInfo = new ArtifactDefinition();
 313
 314         artifactInfo.setArtifactName(ArtifactOperationTest.ARTIFACT_NAME + ".sh");
 315         artifactInfo.setArtifactType("SHELL");
 316         artifactInfo.setDescription("hdkfhskdfgh");
 317         artifactInfo.setArtifactChecksum("UEsDBAoAAAAIAAeLb0bDQz");
 318
 319         artifactInfo.setUserIdCreator(ArtifactOperationTest.USER_ID);
 320         String fullName = "Jim H";
 321         artifactInfo.setUpdaterFullName(fullName);
 322         long time = System.currentTimeMillis();
 323         artifactInfo.setCreatorFullName(fullName);
 324         artifactInfo.setCreationDate(time);
 325         artifactInfo.setLastUpdateDate(time);
 326         artifactInfo.setUserIdLastUpdater(ArtifactOperationTest.USER_ID);
 327         artifactInfo.setArtifactLabel(ArtifactOperationTest.ARTIFACT_NAME);
 328         artifactInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(ArtifactOperationTest.RESOURCE_ID, artifactInfo.getArtifactLabel()));
 329         return artifactInfo;
 330     }
 331
 332     private void deleteAndCreateCategory(String category) {
 333         String[] names = category.split("/");
 334         OperationTestsUtil.deleteAndCreateServiceCategory(category, janusGraphDao);
 335         OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], janusGraphDao);
 336     }
 337
 338     private void deleteAndCreateUser() {
 339         UserData userData = new UserData();
 340         userData.setUserId(ArtifactOperationTest.USER_ID);
 341         userData.setFirstName("first_muUserId");
 342         userData.setLastName("last_muUserId");
 343         userData.setRole("ADMIN");
 344
 345         janusGraphDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), ArtifactOperationTest.USER_ID, UserData.class);
 346         janusGraphDao.createNode(userData, UserData.class);
 347         janusGraphDao.commit();
 348     }
 349
 350     public ResourceMetadataData createResource(String resourceName) {
 351
 352         ResourceMetadataData serviceData1 = new ResourceMetadataData();
 353         serviceData1.getMetadataDataDefinition().setUniqueId(resourceName);
 354         Either<ResourceMetadataData, JanusGraphOperationStatus> createNode = janusGraphDao.createNode(serviceData1, ResourceMetadataData.class);
 355
 356         assertTrue("check resource created", createNode.isLeft());
 357         return createNode.left().value();
 358     }
 359 }