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