catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperationTest.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 com.google.gson.Gson;
  24 import com.google.gson.GsonBuilder;
  25 import fj.data.Either;
  26 import org.apache.commons.lang3.tuple.ImmutablePair;
  27 import org.junit.Before;
  28 import org.junit.BeforeClass;
  29 import org.junit.Test;
  30 import org.junit.runner.RunWith;
  31 import org.mockito.InjectMocks;
  32 import org.mockito.Mockito;
  33 import org.mockito.MockitoAnnotations;
  34 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  35 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  36 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  37 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  38 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  39 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  40 import org.openecomp.sdc.be.model.ArtifactDefinition;
  41 import org.openecomp.sdc.be.model.InterfaceDefinition;
  42 import org.openecomp.sdc.be.model.ModelTestBase;
  43 import org.openecomp.sdc.be.model.Operation;
  44 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  45 import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
  46 import org.openecomp.sdc.be.resources.data.category.CategoryData;
  47 import org.openecomp.sdc.be.resources.data.InterfaceData;
  48 import org.openecomp.sdc.be.resources.data.OperationData;
  49 import org.openecomp.sdc.be.resources.data.UserData;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52 import org.springframework.test.context.ContextConfiguration;
  53 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  54
  55 import static org.mockito.ArgumentMatchers.any;
  56 import static org.mockito.Mockito.when;
  57 import org.junit.Assert;
  58
  59 import static org.junit.Assert.assertNotNull;
  60
  61 import java.util.ArrayList;
  62 import java.util.Collections;
  63 import java.util.List;
  64 import java.util.Map;
  65
  66 @RunWith(SpringJUnit4ClassRunner.class)
  67 @ContextConfiguration("classpath:application-context-test.xml")
  68 public class InterfaceLifecycleOperationTest {
  69     private static final Logger log = LoggerFactory.getLogger(InterfaceLifecycleOperationTest.class);
  70     private Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
  71     private static String USER_ID = "muUserId";
  72     private static String CATEGORY_NAME = "category/mycategory";
  73
  74     JanusGraphGenericDao janusGraphGenericDao = Mockito.mock(JanusGraphGenericDao.class);
  75     @InjectMocks
  76     private InterfaceLifecycleOperation interfaceLifecycleOperation = new InterfaceLifecycleOperation();
  77
  78     @javax.annotation.Resource(name = "property-operation")
  79     private PropertyOperation propertyOperation;
  80
  81     // @Resource(name = "artifact-operation")
  82     // private ArtifactOperation artifactOperation;
  83
  84     @Before
  85     public void createUserAndCategory() {
  86         MockitoAnnotations.initMocks(this);
  87         final String UNIQUE_ID = "UNIQUE_ID";
  88         CategoryData categoryData = new CategoryData(NodeTypeEnum.ResourceCategory);
  89         when(janusGraphGenericDao.createNode(any(),any())).thenReturn(Either.left(categoryData));
  90         deleteAndCreateCategory(CATEGORY_NAME);
  91         deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID);
  92     }
  93
  94     @BeforeClass
  95     public static void setupBeforeClass() {
  96         // ExternalConfiguration.setAppName("catalog-model");
  97         // String appConfigDir = "src/test/resources/config/catalog-model";
  98         // ConfigurationSource configurationSource = new
  99         // FSConfigurationSource(ExternalConfiguration.getChangeListener(),
 100         // appConfigDir);
 101
 102         ModelTestBase.init();
 103
 104     }
 105
 106     @Test
 107     public void testDummy() {
 108
 109         assertNotNull(interfaceLifecycleOperation);
 110
 111     }
 112
 113 /*    @Test
 114     public void addInterfaceToResourceTest() {
 115
 116         String capabilityTypeName = "mycapability1";
 117         String reqName = "host";
 118         String reqNodeName = "tosca.nodes.Compute1";
 119         String rootName = "Root100";
 120         String softwareCompName = "tosca.nodes.SoftwareComponent";
 121         String computeNodeName = "tosca.nodes.Compute";
 122         String myResourceVersion = "300.0";
 123         String reqRelationship = "myrelationship";
 124
 125         ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
 126         resourceOperationTest.setOperations(janusGraphDao, resourceOperation, propertyOperation);
 127
 128         Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "100.0", null, true, true);
 129
 130         String interfaceName = "standard";
 131         InterfaceDefinition interfaceDefinition = buildInterfaceDefinition();
 132
 133         Operation op = buildOperationDefinition();
 134         Map<String, Operation> operations = new HashMap<String, Operation>();
 135         operations.put("Create", op);
 136         interfaceDefinition.setOperations(operations);
 137
 138         Either<InterfaceDefinition, StorageOperationStatus> result = interfaceOperation.addInterfaceToResource(interfaceDefinition, rootResource.getUniqueId(), "standard");
 139
 140         assertTrue(result.isLeft());
 141         log.debug("{}", result.left().value());
 142
 143         Either<Resource, StorageOperationStatus> getResourceRes = resourceOperation.getResource(rootResource.getUniqueId());
 144         assertTrue(getResourceRes.isLeft());
 145         Resource resourceWithInterface = getResourceRes.left().value();
 146         Map<String, InterfaceDefinition> interfaces = resourceWithInterface.getInterfaces();
 147         assertNotNull(interfaces);
 148         assertFalse(interfaces.isEmpty());
 149         InterfaceDefinition interfaceDefinition2 = interfaces.get(interfaceName);
 150         assertNotNull(interfaceDefinition2.getOperations());
 151         assertFalse(interfaceDefinition2.getOperations().isEmpty());
 152
 153     }
 154
 155     @Test
 156     public void updateInterfaceToResourceTest() {
 157
 158         String reqName = "host";
 159         String rootName = "Root200";
 160         String softwareCompName = "tosca.nodes.SoftwareComponent";
 161
 162         ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
 163         resourceOperationTest.setOperations(janusGraphDao, resourceOperation, propertyOperation);
 164
 165         Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "200.0", null, true, true);
 166
 167         String interfaceName = "standard";
 168         InterfaceDefinition interfaceDefinition = buildInterfaceDefinition();
 169
 170         Operation op = buildOperationDefinition();
 171         Map<String, Operation> operations = new HashMap<String, Operation>();
 172         operations.put("create", op);
 173         interfaceDefinition.setOperations(operations);
 174
 175         Either<InterfaceDefinition, StorageOperationStatus> result = interfaceOperation.addInterfaceToResource(interfaceDefinition, rootResource.getUniqueId(), "standard");
 176
 177         ResourceMetadataData resourceData = new ResourceMetadataData();
 178         resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
 179         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
 180         Either<ResourceMetadataData, JanusGraphOperationStatus> updateNode = janusGraphDao.updateNode(resourceData, ResourceMetadataData.class);
 181         assertTrue(updateNode.isLeft());
 182
 183         Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation.getResource(rootResource.getUniqueId());
 184
 185         assertTrue(fetchRootResource.isLeft());
 186         String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
 187         log.debug(rootResourceJson);
 188
 189         Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName, "400.0", rootResource.getName(), true, true);
 190
 191         assertTrue(result.isLeft());
 192         log.debug("{}", result.left().value());
 193
 194         addImplementationToOperation(op);
 195         // String resourceId, String interfaceName, String
 196         // operationName,Operation interf
 197
 198         Either<Operation, StorageOperationStatus> opResult = interfaceOperation.updateInterfaceOperation(softwareComponent.getUniqueId(), "standard", "create", op);
 199         // PrintGraph pg = new PrintGraph();
 200         // System.out.println(pg.buildGraphForWebgraphWiz(janusGraphDao.getGraph().left().value()));
 201         assertTrue(opResult.isLeft());
 202         log.debug("{}", opResult.left().value());
 203
 204         Either<Resource, StorageOperationStatus> getResourceRes = resourceOperation.getResource(softwareComponent.getUniqueId());
 205         assertTrue(getResourceRes.isLeft());
 206         Resource resourceWithInterface = getResourceRes.left().value();
 207         Map<String, InterfaceDefinition> interfaces = resourceWithInterface.getInterfaces();
 208         assertNotNull(interfaces);
 209         assertFalse(interfaces.isEmpty());
 210         InterfaceDefinition interfaceDefinition2 = interfaces.get(interfaceName);
 211         assertNotNull(interfaceDefinition2.getOperations());
 212         assertFalse(interfaceDefinition2.getOperations().isEmpty());
 213         Operation operation = interfaceDefinition2.getOperations().get("create");
 214         assertNotNull(operation);
 215         assertNotNull(operation.getImplementation());
 216     }
 217 */
 218     private void addImplementationToOperation(Operation op) {
 219         ArtifactDataDefinition artifactDataDef = new ArtifactDataDefinition();
 220         artifactDataDef.setArtifactChecksum("YTg2Mjg4MWJhNmI5NzBiNzdDFkMWI=");
 221         artifactDataDef.setArtifactName("create_myRoot.sh");
 222         artifactDataDef.setArtifactLabel("create_myRoot");
 223         artifactDataDef.setArtifactType("SHELL");
 224         artifactDataDef.setDescription("good description");
 225         artifactDataDef.setEsId("esId");
 226         artifactDataDef.setUniqueId(op.getUniqueId() + "." + artifactDataDef.getArtifactLabel());
 227         ArtifactDefinition artifactDef = new ArtifactDefinition(artifactDataDef, "UEsDBAoAAAAIAAeLb0bDQz");
 228         op.setImplementation(artifactDef);
 229     }
 230
 231     private InterfaceDefinition buildInterfaceDefinition() {
 232         InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 233         interfaceDefinition.setType("tosca.interfaces.standard");
 234         interfaceDefinition.setCreationDate(new Long(101232));
 235
 236         return interfaceDefinition;
 237     }
 238
 239     private Operation buildOperationDefinition() {
 240         Operation op = new Operation();
 241         op.setCreationDate(new Long(101232));
 242         op.setDescription("asda");
 243
 244         return op;
 245     }
 246
 247     private void deleteAndCreateCategory(String category) {
 248         String[] names = category.split("/");
 249         OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], janusGraphGenericDao);
 250
 251         /*
 252          * CategoryData categoryData = new CategoryData(); categoryData.setName(category);
 253          *
 254          * janusGraphDao.deleteNode(categoryData, CategoryData.class); Either<CategoryData, JanusGraphOperationStatus> createNode = janusGraphDao .createNode(categoryData, CategoryData.class); System.out.println("after creating caetgory " + createNode);
 255          */
 256
 257     }
 258
 259     private UserData deleteAndCreateUser(String userId, String firstName, String lastName) {
 260         UserData userData = new UserData();
 261         userData.setUserId(userId);
 262         userData.setFirstName(firstName);
 263         userData.setLastName(lastName);
 264
 265         janusGraphGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId,
 266             UserData.class);
 267         janusGraphGenericDao.createNode(userData, UserData.class);
 268         janusGraphGenericDao.commit();
 269
 270         return userData;
 271     }
 272
 273     @Test
 274     public void testGetAllInterfaceLifecycleTypes_TypesNotFound() {
 275         when(janusGraphGenericDao.getByCriteria(NodeTypeEnum.Interface, Collections.emptyMap(),
 276             InterfaceData.class)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 277         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> types = interfaceLifecycleOperation.getAllInterfaceLifecycleTypes();
 278         Assert.assertEquals(types.isRight(), Boolean.TRUE);
 279     }
 280
 281     @Test
 282     public void testGetAllInterfaceLifecycleTypes_Success() {
 283         final String UNIQUE_ID = "UNIQUE_ID";
 284         final String TYPE = "UNIQUE_ID";
 285         InterfaceData interfaceData = new InterfaceData();
 286         interfaceData.getInterfaceDataDefinition().setUniqueId(UNIQUE_ID);
 287         interfaceData.getInterfaceDataDefinition().setType(TYPE);
 288         List<InterfaceData> interfaceDataList = new ArrayList<>();
 289         interfaceDataList.add(interfaceData);
 290         Either<List<InterfaceData>, JanusGraphOperationStatus> allInterfaceTypes = Either.left(interfaceDataList);
 291         when(janusGraphGenericDao
 292             .getByCriteria(NodeTypeEnum.Interface, Collections.emptyMap(), InterfaceData.class)).thenReturn(allInterfaceTypes);
 293
 294         List<ImmutablePair<OperationData, GraphEdge>> list = new ArrayList<>();
 295         Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = Either.left(list);
 296         when(janusGraphGenericDao.getChildrenNodes(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class)).thenReturn(childrenNodes);
 297
 298         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> types = interfaceLifecycleOperation.getAllInterfaceLifecycleTypes();
 299         Assert.assertEquals(types.left().value().size(),1);
 300     }
 301
 302 }