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.Ignore;
  27 import org.junit.Test;
  28 import org.junit.runner.RunWith;
  29 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  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.titan.TitanGenericDao;
  33 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  34 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  35 import org.openecomp.sdc.be.model.*;
  36 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  37 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
  38 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  39 import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
  40 import org.openecomp.sdc.be.resources.data.*;
  41 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  42 import org.slf4j.Logger;
  43 import org.slf4j.LoggerFactory;
  44 import org.springframework.test.context.ContextConfiguration;
  45 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  46
  47 import java.util.ArrayList;
  48 import java.util.HashMap;
  49 import java.util.List;
  50 import java.util.Map;
  51
  52 import static org.junit.Assert.*;
  53 import static org.junit.Assert.assertFalse;
  54 import static org.junit.Assert.assertNotNull;
  55 import static org.junit.Assert.assertTrue;
  56
  57 @RunWith(SpringJUnit4ClassRunner.class)
  58 @ContextConfiguration("classpath:application-context-test.xml")
  59 public class ArtifactOperationTest extends ModelTestBase {
  60
  61     private static final String ARTIFACT_NAME = "myHeatArtifact";
  62
  63     @javax.annotation.Resource(name = "titan-generic-dao")
  64     private TitanGenericDao titanDao;
  65
  66     @javax.annotation.Resource(name = "tosca-operation-facade")
  67     private ToscaOperationFacade toscaOperationFacade;
  68
  69     @javax.annotation.Resource
  70     private ArtifactOperation artifactOperation;
  71
  72     private static final Logger log = LoggerFactory.getLogger(ToscaOperationFacade.class);
  73
  74     private static String RESOURCE_ID = "resourceId";
  75     private static String RESOURCE_ID_2 = "resourceId2";
  76
  77     private static String USER_ID = "muUserId";
  78     private static String CATEGORY_NAME = "category/mycategory";
  79
  80     @BeforeClass
  81     public static void setupBeforeClass() {
  82
  83         ModelTestBase.init();
  84     }
  85
  86     @Before
  87     public void createUserAndCategory() {
  88         deleteAndCreateCategory(CATEGORY_NAME);
  89         deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID, null);
  90     }
  91
  92     @Test
  93     public void testCreateDeleteArtifactWithHeatParams() {
  94
  95         ArtifactDefinition artifactWithHeat = createResourceWithHeat();
  96
  97         List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
  98         assertNotNull(heatParameters);
  99         assertEquals(1, heatParameters.size());
 100         HeatParameterDefinition parameter = heatParameters.get(0);
 101         HeatParameterData parameterData = new HeatParameterData(parameter);
 102         Either<HeatParameterData, TitanOperationStatus> parameterNode = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 103         assertTrue(parameterNode.isLeft());
 104
 105         Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
 106         assertTrue(removeArifact.isLeft());
 107
 108         ArtifactData artifactData = new ArtifactData(artifactWithHeat);
 109         Either<ArtifactData, TitanOperationStatus> artifactAfterDelete = titanDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
 110         assertTrue(artifactAfterDelete.isRight());
 111
 112         Either<HeatParameterData, TitanOperationStatus> parameterNodeAfterDelete = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 113         assertTrue(parameterNodeAfterDelete.isRight());
 114
 115         titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
 116     }
 117
 118     @Test
 119     public void testUpdateArtifactWithHeatParams() {
 120
 121         ArtifactDefinition artifactWithHeat = createResourceWithHeat();
 122
 123         List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
 124         assertNotNull(heatParameters);
 125         assertEquals(1, heatParameters.size());
 126         HeatParameterDefinition parameter = heatParameters.get(0);
 127         HeatParameterData parameterData = new HeatParameterData(parameter);
 128         Either<HeatParameterData, TitanOperationStatus> parameterNode = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 129         assertTrue(parameterNode.isLeft());
 130
 131         // update to artifact without params
 132         ArtifactDefinition artifactNoParams = createArtifactDefinition(USER_ID, RESOURCE_ID, ARTIFACT_NAME);
 133         artifactNoParams.setUniqueId(artifactWithHeat.getUniqueId());
 134         artifactNoParams.setArtifactType("HEAT");
 135         artifactNoParams.setArtifactVersion("2");
 136         artifactNoParams.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 137
 138         Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(artifactNoParams, RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, false);
 139         assertTrue(updateArifact.isLeft());
 140
 141         ArtifactData artifactData = new ArtifactData(artifactWithHeat);
 142         Either<ArtifactData, TitanOperationStatus> artifactAfterUpdate = titanDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
 143         assertTrue(artifactAfterUpdate.isLeft());
 144         ArtifactData artifactAfterUpdateValue = artifactAfterUpdate.left().value();
 145         assertEquals(artifactNoParams.getArtifactVersion(), artifactAfterUpdateValue.getArtifactDataDefinition()
 146                                                                                     .getArtifactVersion());
 147
 148         Either<HeatParameterData, TitanOperationStatus> parameterNodeAfterDelete = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 149         assertTrue(parameterNodeAfterDelete.isRight());
 150
 151         artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
 152         titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
 153         titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class);
 154     }
 155
 156     @Test
 157     public void testUpdateArtifactMetadataWithHeatParams() {
 158
 159         ArtifactDefinition artifactWithHeat = createResourceWithHeat();
 160
 161         List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
 162         assertNotNull(heatParameters);
 163         assertEquals(1, heatParameters.size());
 164         HeatParameterDefinition parameter = heatParameters.get(0);
 165         HeatParameterData parameterData = new HeatParameterData(parameter);
 166         Either<HeatParameterData, TitanOperationStatus> parameterNode = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 167         assertTrue(parameterNode.isLeft());
 168
 169         // update to artifact without params
 170         artifactWithHeat.setArtifactVersion("2");
 171         artifactWithHeat.setArtifactChecksum(null);
 172         artifactWithHeat.setPayloadData(null);
 173
 174         Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(artifactWithHeat, RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, false);
 175         assertTrue(updateArifact.isLeft());
 176
 177         ArtifactData artifactData = new ArtifactData(artifactWithHeat);
 178         Either<ArtifactData, TitanOperationStatus> artifactAfterUpdate = titanDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
 179         assertTrue(artifactAfterUpdate.isLeft());
 180         ArtifactData artifactAfterUpdateValue = artifactAfterUpdate.left().value();
 181         assertEquals(artifactWithHeat.getArtifactVersion(), artifactAfterUpdateValue.getArtifactDataDefinition()
 182                                                                                     .getArtifactVersion());
 183
 184         Either<HeatParameterData, TitanOperationStatus> parameterNodeAfterDelete = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 185         assertTrue(parameterNodeAfterDelete.isLeft());
 186
 187         Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID_2, (String) artifactAfterUpdateValue.getUniqueId(), NodeTypeEnum.Resource, true, false);
 188         removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
 189         titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
 190         titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class);
 191
 192     }
 193
 194     @Test
 195     public void updateHeatArtifactWithTwoResources() {
 196         ArtifactDefinition artifactWithHeat = createResourceWithHeat();
 197
 198         ResourceMetadataData resource2 = createResource(RESOURCE_ID_2);
 199         Map<String, Object> props = new HashMap<>();
 200         props.put(GraphEdgePropertiesDictionary.NAME.getProperty(), ArtifactGroupTypeEnum.DEPLOYMENT.name());
 201         Either<GraphRelation, TitanOperationStatus> createRelation = titanDao.createRelation(resource2, new ArtifactData(artifactWithHeat), GraphEdgeLabels.ARTIFACT_REF, props);
 202         assertTrue(createRelation.isLeft());
 203
 204         List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
 205         assertNotNull(heatParameters);
 206         assertEquals(1, heatParameters.size());
 207         HeatParameterDefinition parameter = heatParameters.get(0);
 208         HeatParameterData parameterData = new HeatParameterData(parameter);
 209         Either<HeatParameterData, TitanOperationStatus> parameterNode = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 210         assertTrue(parameterNode.isLeft());
 211
 212         ArtifactDefinition atifactToUpdate = new ArtifactDefinition(artifactWithHeat);
 213
 214         // update to artifact without params
 215         atifactToUpdate.setArtifactVersion("2");
 216         atifactToUpdate.setArtifactChecksum(null);
 217         atifactToUpdate.setPayloadData(null);
 218
 219         HeatParameterDefinition heatParamUpdate = new HeatParameterDefinition(parameter);
 220         List<HeatParameterDefinition> heatParametersUpdated = new ArrayList<>();
 221         heatParamUpdate.setCurrentValue("55");
 222         heatParametersUpdated.add(heatParamUpdate);
 223         atifactToUpdate.setListHeatParameters(heatParametersUpdated);
 224
 225         Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(atifactToUpdate, RESOURCE_ID_2, atifactToUpdate.getUniqueId(), NodeTypeEnum.Resource, false);
 226         assertTrue(updateArifact.isLeft());
 227
 228         // verify old artifact and parameter still exist
 229         ArtifactData artifactData = new ArtifactData(artifactWithHeat);
 230         Either<ArtifactData, TitanOperationStatus> origArtifact = titanDao.getNode(artifactData.getUniqueIdKey(), 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, TitanOperationStatus> parameterNodeAfterDelete = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 237         assertTrue(parameterNodeAfterDelete.isLeft());
 238
 239         // verify new artifact and new parameter
 240         ArtifactDefinition artifactDefinitionUpdated = updateArifact.left().value();
 241         ArtifactData artifactDataUpdated = new ArtifactData(artifactDefinitionUpdated);
 242         Either<ArtifactData, TitanOperationStatus> updatedArtifact = titanDao.getNode(artifactDataUpdated.getUniqueIdKey(), artifactDataUpdated.getUniqueId(), ArtifactData.class);
 243         assertTrue(updatedArtifact.isLeft());
 244         ArtifactData updatedArtifactData = updatedArtifact.left().value();
 245         assertEquals(atifactToUpdate.getArtifactVersion(), updatedArtifactData.getArtifactDataDefinition()
 246                                                                               .getArtifactVersion());
 247         assertFalse(((String) updatedArtifactData.getUniqueId()).equalsIgnoreCase((String) origArtifactData.getUniqueId()));
 248
 249         List<HeatParameterDefinition> heatParametersAfterUpdate = artifactDefinitionUpdated.getListHeatParameters();
 250         assertNotNull(heatParametersAfterUpdate);
 251         assertEquals(1, heatParametersAfterUpdate.size());
 252         HeatParameterDefinition UpdatedHeatParameter = heatParametersAfterUpdate.get(0);
 253         assertFalse(UpdatedHeatParameter.getUniqueId().equalsIgnoreCase((String) parameterData.getUniqueId()));
 254         Either<HeatParameterData, TitanOperationStatus> parameterNodeAfterUpdate = titanDao.getNode(new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(), UpdatedHeatParameter.getUniqueId(), HeatParameterData.class);
 255         assertTrue(parameterNodeAfterUpdate.isLeft());
 256
 257         // delete new artifact
 258         Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID_2, artifactDefinitionUpdated.getUniqueId(), NodeTypeEnum.Resource, true, false);
 259         assertTrue(removeArifact.isLeft());
 260
 261         // verify old artifact and parameter still exist
 262         origArtifact = titanDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
 263         assertTrue(origArtifact.isLeft());
 264         origArtifactData = origArtifact.left().value();
 265         assertEquals(artifactWithHeat.getArtifactVersion(), origArtifactData.getArtifactDataDefinition()
 266                                                                             .getArtifactVersion());
 267
 268         parameterNodeAfterDelete = titanDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
 269         assertTrue(parameterNodeAfterDelete.isLeft());
 270
 271         // verify new artifact is deleted
 272         Either<ArtifactData, TitanOperationStatus> artifactAfterDelete = titanDao.getNode(artifactDataUpdated.getUniqueIdKey(), artifactDataUpdated.getUniqueId(), ArtifactData.class);
 273         assertTrue(artifactAfterDelete.isRight());
 274
 275         parameterNodeAfterDelete = titanDao.getNode(new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(), new HeatParameterData(UpdatedHeatParameter).getUniqueId(), HeatParameterData.class);
 276         assertTrue(parameterNodeAfterDelete.isRight());
 277
 278         artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
 279         titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
 280         titanDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class);
 281     }
 282
 283     private ArtifactDefinition createResourceWithHeat() {
 284         ResourceMetadataData resource = createResource(RESOURCE_ID);
 285         ArtifactDefinition artifactDefinition = createArtifactDefinition(USER_ID, RESOURCE_ID, ARTIFACT_NAME);
 286         artifactDefinition.setArtifactType("HEAT");
 287         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 288
 289         List<HeatParameterDefinition> heatParams = new ArrayList<>();
 290         HeatParameterDefinition heatParam = new HeatParameterDefinition();
 291         heatParam.setCurrentValue("11");
 292         heatParam.setDefaultValue("22");
 293         heatParam.setDescription("desc");
 294         heatParam.setName("myParam");
 295         heatParam.setType("number");
 296         heatParams.add(heatParam);
 297         artifactDefinition.setListHeatParameters(heatParams);
 298
 299         Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation.addArifactToComponent(artifactDefinition, RESOURCE_ID, NodeTypeEnum.Resource, true, false);
 300         assertTrue(artifact.isLeft());
 301         return artifact.left().value();
 302     }
 303
 304     private ArtifactDefinition addArtifactToService(String userId, String serviceId, String artifactName) {
 305         ArtifactDefinition artifactInfo = createArtifactDefinition(userId, serviceId, artifactName);
 306
 307         Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation.addArifactToComponent(artifactInfo, serviceId, NodeTypeEnum.Service, true, true);
 308         assertTrue(artifact.isLeft());
 309         return artifact.left().value();
 310     }
 311
 312     private ArtifactDefinition createArtifactDefinition(String userId, String serviceId, String artifactName) {
 313         ArtifactDefinition artifactInfo = new ArtifactDefinition();
 314
 315         artifactInfo.setArtifactName(artifactName + ".sh");
 316         artifactInfo.setArtifactType("SHELL");
 317         artifactInfo.setDescription("hdkfhskdfgh");
 318         artifactInfo.setArtifactChecksum("UEsDBAoAAAAIAAeLb0bDQz");
 319
 320         artifactInfo.setUserIdCreator(userId);
 321         String fullName = "Jim H";
 322         artifactInfo.setUpdaterFullName(fullName);
 323         long time = System.currentTimeMillis();
 324         artifactInfo.setCreatorFullName(fullName);
 325         artifactInfo.setCreationDate(time);
 326         artifactInfo.setLastUpdateDate(time);
 327         artifactInfo.setUserIdLastUpdater(userId);
 328         artifactInfo.setArtifactLabel(artifactName);
 329         artifactInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(serviceId, artifactInfo.getArtifactLabel()));
 330         return artifactInfo;
 331     }
 332
 333     public Service createService(String userId, CategoryDefinition category, String serviceName, String serviceVersion, boolean isHighestVersion) {
 334
 335         Service service = buildServiceMetadata(userId, category, serviceName, serviceVersion);
 336
 337         service.setHighestVersion(isHighestVersion);
 338
 339         Either<Service, StorageOperationStatus> result = toscaOperationFacade.createToscaComponent(service);
 340
 341         log.info(result.toString());
 342         assertTrue(result.isLeft());
 343         Service resultService = result.left().value();
 344
 345         assertEquals("check resource state", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, resultService.getLifecycleState());
 346
 347         return resultService;
 348     }
 349
 350     private Service buildServiceMetadata(String userId, CategoryDefinition category, String serviceName, String serviceVersion) {
 351
 352         Service service = new Service();
 353         service.setName(serviceName);
 354         service.setVersion(serviceVersion);
 355         service.setDescription("description 1");
 356
 357         service.setCreatorUserId(userId);
 358         service.setContactId("contactId@sdc.com");
 359         List<CategoryDefinition> categories = new ArrayList<>();
 360         categories.add(category);
 361         service.setCategories(categories);
 362         service.setIcon("images/my.png");
 363         List<String> tags = new ArrayList<>();
 364         tags.add("TAG1");
 365         tags.add("TAG2");
 366         service.setTags(tags);
 367         return service;
 368     }
 369
 370     private void deleteAndCreateCategory(String category) {
 371         String[] names = category.split("/");
 372         OperationTestsUtil.deleteAndCreateServiceCategory(category, titanDao);
 373         OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanDao);
 374     }
 375
 376     private UserData deleteAndCreateUser(String userId, String firstName, String lastName, String role) {
 377         UserData userData = new UserData();
 378         userData.setUserId(userId);
 379         userData.setFirstName(firstName);
 380         userData.setLastName(lastName);
 381         if (role != null && !role.isEmpty()) {
 382             userData.setRole(role);
 383         } else {
 384             userData.setRole("ADMIN");
 385         }
 386
 387         titanDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
 388         titanDao.createNode(userData, UserData.class);
 389         titanDao.commit();
 390
 391         return userData;
 392     }
 393
 394     public ResourceMetadataData createResource(String resourceName) {
 395
 396         ResourceMetadataData serviceData1 = new ResourceMetadataData();
 397         serviceData1.getMetadataDataDefinition().setUniqueId(resourceName);
 398         Either<ResourceMetadataData, TitanOperationStatus> createNode = titanDao.createNode(serviceData1, ResourceMetadataData.class);
 399
 400         assertTrue("check resource created", createNode.isLeft());
 401         return createNode.left().value();
 402     }
 403 }