2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.be.model.operations.impl;
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.category.CategoryDefinition;
36 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
37 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
38 import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
39 import org.openecomp.sdc.be.resources.data.*;
40 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
41 import org.slf4j.Logger;
42 import org.slf4j.LoggerFactory;
43 import org.springframework.test.context.ContextConfiguration;
44 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
46 import java.util.ArrayList;
47 import java.util.HashMap;
48 import java.util.List;
51 import static org.junit.Assert.*;
52 import static org.junit.Assert.assertFalse;
53 import static org.junit.Assert.assertNotNull;
54 import static org.junit.Assert.assertTrue;
56 @RunWith(SpringJUnit4ClassRunner.class)
57 @ContextConfiguration("classpath:application-context-test.xml")
58 public class ArtifactOperationTest extends ModelTestBase {
60 private static final String ARTIFACT_NAME = "myHeatArtifact";
62 @javax.annotation.Resource(name = "janusgraph-generic-dao")
63 private JanusGraphGenericDao janusGraphDao;
65 @javax.annotation.Resource(name = "tosca-operation-facade")
66 private ToscaOperationFacade toscaOperationFacade;
68 @javax.annotation.Resource
69 private ArtifactOperation artifactOperation;
71 private static final Logger log = LoggerFactory.getLogger(ToscaOperationFacade.class);
73 private static String RESOURCE_ID = "resourceId";
74 private static String RESOURCE_ID_2 = "resourceId2";
76 private static String USER_ID = "muUserId";
77 private static String CATEGORY_NAME = "category/mycategory";
80 public static void setupBeforeClass() {
86 public void createUserAndCategory() {
87 deleteAndCreateCategory(CATEGORY_NAME);
88 deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID, null);
92 public void testCreateDeleteArtifactWithHeatParams() {
94 ArtifactDefinition artifactWithHeat = createResourceWithHeat();
96 List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
97 assertNotNull(heatParameters);
98 assertEquals(1, heatParameters.size());
99 HeatParameterDefinition parameter = heatParameters.get(0);
100 HeatParameterData parameterData = new HeatParameterData(parameter);
101 Either<HeatParameterData, JanusGraphOperationStatus> parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
102 assertTrue(parameterNode.isLeft());
104 Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
105 assertTrue(removeArifact.isLeft());
107 ArtifactData artifactData = new ArtifactData(artifactWithHeat);
108 Either<ArtifactData, JanusGraphOperationStatus> artifactAfterDelete = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
109 assertTrue(artifactAfterDelete.isRight());
111 Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
112 assertTrue(parameterNodeAfterDelete.isRight());
114 janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
118 public void testUpdateArtifactWithHeatParams() {
120 ArtifactDefinition artifactWithHeat = createResourceWithHeat();
122 List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
123 assertNotNull(heatParameters);
124 assertEquals(1, heatParameters.size());
125 HeatParameterDefinition parameter = heatParameters.get(0);
126 HeatParameterData parameterData = new HeatParameterData(parameter);
127 Either<HeatParameterData, JanusGraphOperationStatus> parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
128 assertTrue(parameterNode.isLeft());
130 // update to artifact without params
131 ArtifactDefinition artifactNoParams = createArtifactDefinition(USER_ID, RESOURCE_ID, ARTIFACT_NAME);
132 artifactNoParams.setUniqueId(artifactWithHeat.getUniqueId());
133 artifactNoParams.setArtifactType("HEAT");
134 artifactNoParams.setArtifactVersion("2");
135 artifactNoParams.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
137 Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(artifactNoParams, RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, false);
138 assertTrue(updateArifact.isLeft());
140 ArtifactData artifactData = new ArtifactData(artifactWithHeat);
141 Either<ArtifactData, JanusGraphOperationStatus> artifactAfterUpdate = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
142 assertTrue(artifactAfterUpdate.isLeft());
143 ArtifactData artifactAfterUpdateValue = artifactAfterUpdate.left().value();
144 assertEquals(artifactNoParams.getArtifactVersion(), artifactAfterUpdateValue.getArtifactDataDefinition()
145 .getArtifactVersion());
147 Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
148 assertTrue(parameterNodeAfterDelete.isRight());
150 artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
151 janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
152 janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class);
156 public void testUpdateArtifactMetadataWithHeatParams() {
158 ArtifactDefinition artifactWithHeat = createResourceWithHeat();
160 List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
161 assertNotNull(heatParameters);
162 assertEquals(1, heatParameters.size());
163 HeatParameterDefinition parameter = heatParameters.get(0);
164 HeatParameterData parameterData = new HeatParameterData(parameter);
165 Either<HeatParameterData, JanusGraphOperationStatus> parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
166 assertTrue(parameterNode.isLeft());
168 // update to artifact without params
169 artifactWithHeat.setArtifactVersion("2");
170 artifactWithHeat.setArtifactChecksum(null);
171 artifactWithHeat.setPayloadData(null);
173 Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(artifactWithHeat, RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, false);
174 assertTrue(updateArifact.isLeft());
176 ArtifactData artifactData = new ArtifactData(artifactWithHeat);
177 Either<ArtifactData, JanusGraphOperationStatus> artifactAfterUpdate = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
178 assertTrue(artifactAfterUpdate.isLeft());
179 ArtifactData artifactAfterUpdateValue = artifactAfterUpdate.left().value();
180 assertEquals(artifactWithHeat.getArtifactVersion(), artifactAfterUpdateValue.getArtifactDataDefinition()
181 .getArtifactVersion());
183 Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
184 assertTrue(parameterNodeAfterDelete.isLeft());
186 Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID_2, (String) artifactAfterUpdateValue.getUniqueId(), NodeTypeEnum.Resource, true, false);
187 removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
188 janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
189 janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class);
194 public void updateHeatArtifactWithTwoResources() {
195 ArtifactDefinition artifactWithHeat = createResourceWithHeat();
197 ResourceMetadataData resource2 = createResource(RESOURCE_ID_2);
198 Map<String, Object> props = new HashMap<>();
199 props.put(GraphEdgePropertiesDictionary.NAME.getProperty(), ArtifactGroupTypeEnum.DEPLOYMENT.name());
200 Either<GraphRelation, JanusGraphOperationStatus> createRelation = janusGraphDao.createRelation(resource2, new ArtifactData(artifactWithHeat), GraphEdgeLabels.ARTIFACT_REF, props);
201 assertTrue(createRelation.isLeft());
203 List<HeatParameterDefinition> heatParameters = artifactWithHeat.getListHeatParameters();
204 assertNotNull(heatParameters);
205 assertEquals(1, heatParameters.size());
206 HeatParameterDefinition parameter = heatParameters.get(0);
207 HeatParameterData parameterData = new HeatParameterData(parameter);
208 Either<HeatParameterData, JanusGraphOperationStatus> parameterNode = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
209 assertTrue(parameterNode.isLeft());
211 ArtifactDefinition atifactToUpdate = new ArtifactDefinition(artifactWithHeat);
213 // update to artifact without params
214 atifactToUpdate.setArtifactVersion("2");
215 atifactToUpdate.setArtifactChecksum(null);
216 atifactToUpdate.setPayloadData(null);
218 HeatParameterDefinition heatParamUpdate = new HeatParameterDefinition(parameter);
219 List<HeatParameterDefinition> heatParametersUpdated = new ArrayList<>();
220 heatParamUpdate.setCurrentValue("55");
221 heatParametersUpdated.add(heatParamUpdate);
222 atifactToUpdate.setListHeatParameters(heatParametersUpdated);
224 Either<ArtifactDefinition, StorageOperationStatus> updateArifact = artifactOperation.updateArifactOnResource(atifactToUpdate, RESOURCE_ID_2, atifactToUpdate.getUniqueId(), NodeTypeEnum.Resource, false);
225 assertTrue(updateArifact.isLeft());
227 // verify old artifact and parameter still exist
228 ArtifactData artifactData = new ArtifactData(artifactWithHeat);
229 Either<ArtifactData, JanusGraphOperationStatus> origArtifact = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
230 assertTrue(origArtifact.isLeft());
231 ArtifactData origArtifactData = origArtifact.left().value();
232 assertEquals(artifactWithHeat.getArtifactVersion(), origArtifactData.getArtifactDataDefinition()
233 .getArtifactVersion());
235 Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
236 assertTrue(parameterNodeAfterDelete.isLeft());
238 // verify new artifact and new parameter
239 ArtifactDefinition artifactDefinitionUpdated = updateArifact.left().value();
240 ArtifactData artifactDataUpdated = new ArtifactData(artifactDefinitionUpdated);
241 Either<ArtifactData, JanusGraphOperationStatus> updatedArtifact = janusGraphDao.getNode(artifactDataUpdated.getUniqueIdKey(), artifactDataUpdated.getUniqueId(), ArtifactData.class);
242 assertTrue(updatedArtifact.isLeft());
243 ArtifactData updatedArtifactData = updatedArtifact.left().value();
244 assertEquals(atifactToUpdate.getArtifactVersion(), updatedArtifactData.getArtifactDataDefinition()
245 .getArtifactVersion());
246 assertFalse(((String) updatedArtifactData.getUniqueId()).equalsIgnoreCase((String) origArtifactData.getUniqueId()));
248 List<HeatParameterDefinition> heatParametersAfterUpdate = artifactDefinitionUpdated.getListHeatParameters();
249 assertNotNull(heatParametersAfterUpdate);
250 assertEquals(1, heatParametersAfterUpdate.size());
251 HeatParameterDefinition UpdatedHeatParameter = heatParametersAfterUpdate.get(0);
252 assertFalse(UpdatedHeatParameter.getUniqueId().equalsIgnoreCase((String) parameterData.getUniqueId()));
253 Either<HeatParameterData, JanusGraphOperationStatus> parameterNodeAfterUpdate = janusGraphDao.getNode(new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(), UpdatedHeatParameter.getUniqueId(), HeatParameterData.class);
254 assertTrue(parameterNodeAfterUpdate.isLeft());
256 // delete new artifact
257 Either<ArtifactDefinition, StorageOperationStatus> removeArifact = artifactOperation.removeArifactFromResource(RESOURCE_ID_2, artifactDefinitionUpdated.getUniqueId(), NodeTypeEnum.Resource, true, false);
258 assertTrue(removeArifact.isLeft());
260 // verify old artifact and parameter still exist
261 origArtifact = janusGraphDao.getNode(artifactData.getUniqueIdKey(), artifactData.getUniqueId(), ArtifactData.class);
262 assertTrue(origArtifact.isLeft());
263 origArtifactData = origArtifact.left().value();
264 assertEquals(artifactWithHeat.getArtifactVersion(), origArtifactData.getArtifactDataDefinition()
265 .getArtifactVersion());
267 parameterNodeAfterDelete = janusGraphDao.getNode(parameterData.getUniqueIdKey(), parameterData.getUniqueId(), HeatParameterData.class);
268 assertTrue(parameterNodeAfterDelete.isLeft());
270 // verify new artifact is deleted
271 Either<ArtifactData, JanusGraphOperationStatus> artifactAfterDelete = janusGraphDao.getNode(artifactDataUpdated.getUniqueIdKey(), artifactDataUpdated.getUniqueId(), ArtifactData.class);
272 assertTrue(artifactAfterDelete.isRight());
274 parameterNodeAfterDelete = janusGraphDao.getNode(new HeatParameterData(UpdatedHeatParameter).getUniqueIdKey(), new HeatParameterData(UpdatedHeatParameter).getUniqueId(), HeatParameterData.class);
275 assertTrue(parameterNodeAfterDelete.isRight());
277 artifactOperation.removeArifactFromResource(RESOURCE_ID, artifactWithHeat.getUniqueId(), NodeTypeEnum.Resource, true, false);
278 janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID), ResourceMetadataData.class);
279 janusGraphDao.deleteNode(new UniqueIdData(NodeTypeEnum.Resource, RESOURCE_ID_2), ResourceMetadataData.class);
282 private ArtifactDefinition createResourceWithHeat() {
283 ResourceMetadataData resource = createResource(RESOURCE_ID);
284 ArtifactDefinition artifactDefinition = createArtifactDefinition(USER_ID, RESOURCE_ID, ARTIFACT_NAME);
285 artifactDefinition.setArtifactType("HEAT");
286 artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
288 List<HeatParameterDefinition> heatParams = new ArrayList<>();
289 HeatParameterDefinition heatParam = new HeatParameterDefinition();
290 heatParam.setCurrentValue("11");
291 heatParam.setDefaultValue("22");
292 heatParam.setDescription("desc");
293 heatParam.setName("myParam");
294 heatParam.setType("number");
295 heatParams.add(heatParam);
296 artifactDefinition.setListHeatParameters(heatParams);
298 Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation.addArifactToComponent(artifactDefinition, RESOURCE_ID, NodeTypeEnum.Resource, true, false);
299 assertTrue(artifact.isLeft());
300 return artifact.left().value();
303 private ArtifactDefinition addArtifactToService(String userId, String serviceId, String artifactName) {
304 ArtifactDefinition artifactInfo = createArtifactDefinition(userId, serviceId, artifactName);
306 Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation.addArifactToComponent(artifactInfo, serviceId, NodeTypeEnum.Service, true, true);
307 assertTrue(artifact.isLeft());
308 return artifact.left().value();
311 private ArtifactDefinition createArtifactDefinition(String userId, String serviceId, String artifactName) {
312 ArtifactDefinition artifactInfo = new ArtifactDefinition();
314 artifactInfo.setArtifactName(artifactName + ".sh");
315 artifactInfo.setArtifactType("SHELL");
316 artifactInfo.setDescription("hdkfhskdfgh");
317 artifactInfo.setArtifactChecksum("UEsDBAoAAAAIAAeLb0bDQz");
319 artifactInfo.setUserIdCreator(userId);
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(userId);
327 artifactInfo.setArtifactLabel(artifactName);
328 artifactInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(serviceId, artifactInfo.getArtifactLabel()));
332 public Service createService(String userId, CategoryDefinition category, String serviceName, String serviceVersion, boolean isHighestVersion) {
334 Service service = buildServiceMetadata(userId, category, serviceName, serviceVersion);
336 service.setHighestVersion(isHighestVersion);
338 Either<Service, StorageOperationStatus> result = toscaOperationFacade.createToscaComponent(service);
340 log.info(result.toString());
341 assertTrue(result.isLeft());
342 Service resultService = result.left().value();
344 assertEquals("check resource state", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, resultService.getLifecycleState());
346 return resultService;
349 private Service buildServiceMetadata(String userId, CategoryDefinition category, String serviceName, String serviceVersion) {
351 Service service = new Service();
352 service.setName(serviceName);
353 service.setVersion(serviceVersion);
354 service.setDescription("description 1");
356 service.setCreatorUserId(userId);
357 service.setContactId("contactId@sdc.com");
358 List<CategoryDefinition> categories = new ArrayList<>();
359 categories.add(category);
360 service.setCategories(categories);
361 service.setIcon("images/my.png");
362 List<String> tags = new ArrayList<>();
365 service.setTags(tags);
369 private void deleteAndCreateCategory(String category) {
370 String[] names = category.split("/");
371 OperationTestsUtil.deleteAndCreateServiceCategory(category, janusGraphDao);
372 OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], janusGraphDao);
375 private UserData deleteAndCreateUser(String userId, String firstName, String lastName, String role) {
376 UserData userData = new UserData();
377 userData.setUserId(userId);
378 userData.setFirstName(firstName);
379 userData.setLastName(lastName);
380 if (role != null && !role.isEmpty()) {
381 userData.setRole(role);
383 userData.setRole("ADMIN");
386 janusGraphDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
387 janusGraphDao.createNode(userData, UserData.class);
388 janusGraphDao.commit();
393 public ResourceMetadataData createResource(String resourceName) {
395 ResourceMetadataData serviceData1 = new ResourceMetadataData();
396 serviceData1.getMetadataDataDefinition().setUniqueId(resourceName);
397 Either<ResourceMetadataData, JanusGraphOperationStatus> createNode = janusGraphDao.createNode(serviceData1, ResourceMetadataData.class);
399 assertTrue("check resource created", createNode.isLeft());
400 return createNode.left().value();