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