catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.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  * Modifications copyright (c) 2019 Nokia
  20  * ================================================================================
  21  */
  22
  23 package org.openecomp.sdc.be.components;
  24
  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.mockito.Mockito;
  31 import org.mockito.stubbing.Answer;
  32 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  33 import org.openecomp.sdc.be.components.impl.ImportUtils;
  34 import org.openecomp.sdc.be.components.impl.ImportUtilsTest;
  35 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
  36 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
  37 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  38 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  39 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
  40 import org.openecomp.sdc.be.config.Configuration;
  41 import org.openecomp.sdc.be.config.ConfigurationManager;
  42 import org.openecomp.sdc.be.dao.api.ActionStatus;
  43 import org.openecomp.sdc.be.impl.ComponentsUtils;
  44 import org.openecomp.sdc.be.model.CapabilityDefinition;
  45 import org.openecomp.sdc.be.model.PropertyConstraint;
  46 import org.openecomp.sdc.be.model.PropertyDefinition;
  47 import org.openecomp.sdc.be.model.RequirementDefinition;
  48 import org.openecomp.sdc.be.model.Resource;
  49 import org.openecomp.sdc.be.model.UploadResourceInfo;
  50 import org.openecomp.sdc.be.model.User;
  51 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  52 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
  53 import org.openecomp.sdc.be.model.tosca.constraints.GreaterOrEqualConstraint;
  54 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  55 import org.openecomp.sdc.be.user.UserBusinessLogic;
  56 import org.openecomp.sdc.be.utils.TypeUtils;
  57 import org.openecomp.sdc.common.api.ConfigurationSource;
  58 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  59 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  60 import org.openecomp.sdc.exception.PolicyException;
  61 import org.openecomp.sdc.exception.ResponseFormat;
  62
  63 import java.io.IOException;
  64 import java.util.Collections;
  65 import java.util.HashMap;
  66 import java.util.List;
  67 import java.util.Map;
  68
  69 import static org.junit.Assert.assertEquals;
  70 import static org.junit.Assert.assertNotNull;
  71 import static org.junit.Assert.assertSame;
  72 import static org.junit.Assert.assertTrue;
  73 import static org.mockito.Mockito.when;
  74
  75 public class ResourceImportManagerTest {
  76
  77     private static ConfigurationManager configurationManager;
  78     static ResourceImportManager importManager;
  79     static AuditingManager auditingManager = Mockito.mock(AuditingManager.class);
  80     static ResponseFormatManager responseFormatManager = Mockito.mock(ResponseFormatManager.class);
  81     static ResourceBusinessLogic resourceBusinessLogic = Mockito.mock(ResourceBusinessLogic.class);
  82     static UserBusinessLogic userAdmin = Mockito.mock(UserBusinessLogic.class);
  83     static ToscaOperationFacade toscaOperationFacade =  Mockito.mock(ToscaOperationFacade.class);
  84
  85     protected static final ComponentsUtils componentsUtils = Mockito.mock(ComponentsUtils.class);
  86     private static final CapabilityTypeOperation capabilityTypeOperation = Mockito.mock(CapabilityTypeOperation.class);
  87
  88     @BeforeClass
  89     public static void beforeClass() {
  90         importManager = new ResourceImportManager(componentsUtils, capabilityTypeOperation);
  91         importManager.setAuditingManager(auditingManager);
  92         when(toscaOperationFacade.getLatestByToscaResourceName(Mockito.anyString())).thenReturn(Either.left(null));
  93         importManager.setResponseFormatManager(responseFormatManager);
  94         importManager.setResourceBusinessLogic(resourceBusinessLogic);
  95         importManager.setToscaOperationFacade(toscaOperationFacade);
  96
  97         String appConfigDir = "src/test/resources/config/catalog-be";
  98         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
  99         configurationManager = new ConfigurationManager(configurationSource);
 100
 101         Configuration configuration = new Configuration();
 102         configuration.setJanusGraphInMemoryGraph(true);
 103         configurationManager.setConfiguration(configuration);
 104     }
 105
 106     @Before
 107     public void beforeTest() {
 108         Mockito.reset(auditingManager, responseFormatManager, resourceBusinessLogic, userAdmin);
 109     }
 110
 111     @Test
 112     public void testBasicResourceCreation() throws IOException {
 113         UploadResourceInfo resourceMD = createDummyResourceMD();
 114
 115         User user = new User();
 116         user.setUserId(resourceMD.getContactId());
 117         user.setRole("ADMIN");
 118         user.setFirstName("Jhon");
 119         user.setLastName("Doh");
 120         when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(user);
 121
 122         setResourceBusinessLogicMock();
 123
 124         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
 125
 126         ImmutablePair<Resource, ActionStatus> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
 127         Resource resource = createResource.left;
 128
 129         testSetConstantMetaData(resource);
 130         testSetMetaDataFromJson(resource, resourceMD);
 131
 132         testSetDerivedFrom(resource);
 133         testSetProperties(resource);
 134
 135         Mockito.verify(resourceBusinessLogic, Mockito.times(1)).propagateStateToCertified(Mockito.eq(user), Mockito.eq(resource), Mockito.any(LifecycleChangeInfoWithAction.class), Mockito.eq(false), Mockito.eq(true), Mockito.eq(false));
 136     }
 137
 138     @Test()
 139     public void testResourceCreationFailed() throws IOException {
 140         UploadResourceInfo resourceMD = createDummyResourceMD();
 141         User user = new User();
 142         user.setUserId(resourceMD.getContactId());
 143         when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(user);
 144         ResponseFormat dummyResponseFormat = createGeneralErrorInfo();
 145
 146         when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(dummyResponseFormat);
 147         setResourceBusinessLogicMock();
 148
 149         String jsonContent = "this is an invalid yml!";
 150         ComponentException errorInfoFromTest = null;
 151         try {
 152             importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
 153         }catch (ComponentException e){
 154             errorInfoFromTest = e;
 155         }
 156         assertNotNull(errorInfoFromTest);
 157         assertEquals(errorInfoFromTest.getActionStatus(), ActionStatus.GENERAL_ERROR);
 158
 159         Mockito.verify(resourceBusinessLogic, Mockito.times(0)).createOrUpdateResourceByImport(Mockito.any(Resource.class), Mockito.eq(user), Mockito.eq(true), Mockito.eq(false), Mockito.eq(true), Mockito.eq(null), Mockito.eq(null), Mockito.eq(false));
 160         Mockito.verify(resourceBusinessLogic, Mockito.times(0)).propagateStateToCertified(Mockito.eq(user), Mockito.any(Resource.class), Mockito.any(LifecycleChangeInfoWithAction.class), Mockito.eq(false), Mockito.eq(true), Mockito.eq(false));
 161     }
 162
 163     @Test
 164     public void testResourceCreationWithCapabilities() throws IOException {
 165         UploadResourceInfo resourceMD = createDummyResourceMD();
 166         User user = new User();
 167         user.setUserId(resourceMD.getContactId());
 168         when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(user);
 169
 170         setResourceBusinessLogicMock();
 171
 172         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
 173
 174         ImmutablePair<Resource, ActionStatus> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
 175         Resource resource = createResource.left;
 176         testSetCapabilities(resource);
 177
 178         Mockito.verify(resourceBusinessLogic, Mockito.times(1)).propagateStateToCertified(Mockito.eq(user), Mockito.eq(resource), Mockito.any(LifecycleChangeInfoWithAction.class), Mockito.eq(false), Mockito.eq(true), Mockito.eq(false));
 179         Mockito.verify(resourceBusinessLogic, Mockito.times(1)).createOrUpdateResourceByImport(resource, user, true, false, true, null, null, false);
 180
 181     }
 182
 183     @Test
 184     public void testResourceCreationWithRequirments() throws IOException {
 185         UploadResourceInfo resourceMD = createDummyResourceMD();
 186         User user = new User();
 187         user.setUserId(resourceMD.getContactId());
 188         when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(user);
 189
 190         setResourceBusinessLogicMock();
 191
 192         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-port.yml");
 193
 194         ImmutablePair<Resource, ActionStatus> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
 195         testSetRequirments(createResource.left);
 196
 197     }
 198
 199     private void setResourceBusinessLogicMock() {
 200         when(resourceBusinessLogic.getUserAdmin()).thenReturn(userAdmin);
 201         when(resourceBusinessLogic.createOrUpdateResourceByImport(Mockito.any(Resource.class), Mockito.any(User.class), Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.eq(null), Mockito.eq(null), Mockito.eq(false)))
 202                 .thenAnswer((Answer<ImmutablePair<Resource, ActionStatus>>) invocation -> {
 203                     Object[] args = invocation.getArguments();
 204                     return new ImmutablePair<>((Resource) args[0], ActionStatus.CREATED);
 205
 206                 });
 207         when(resourceBusinessLogic.propagateStateToCertified(Mockito.any(User.class), Mockito.any(Resource.class), Mockito.any(LifecycleChangeInfoWithAction.class), Mockito.eq(false), Mockito.eq(true), Mockito.eq(false)))
 208                 .thenAnswer((Answer<Resource>) invocation -> {
 209                     Object[] args = invocation.getArguments();
 210                     return (Resource) args[1];
 211
 212                 });
 213         when(resourceBusinessLogic.createResourceByDao(Mockito.any(Resource.class), Mockito.any(User.class), Mockito.any(AuditingActionEnum.class), Mockito.anyBoolean(), Mockito.anyBoolean())).thenAnswer((Answer<Either<Resource, ResponseFormat>>) invocation -> {
 214             Object[] args = invocation.getArguments();
 215             return Either.left((Resource) args[0]);
 216
 217         });
 218         when(resourceBusinessLogic.validateResourceBeforeCreate(Mockito.any(Resource.class), Mockito.any(User.class), Mockito.any(AuditingActionEnum.class), Mockito.eq(false), Mockito.eq(null))).thenAnswer((Answer<Either<Resource, ResponseFormat>>) invocation -> {
 219             Object[] args = invocation.getArguments();
 220             return Either.left((Resource) args[0]);
 221
 222         });
 223
 224         Boolean either = true;
 225         when(resourceBusinessLogic.validatePropertiesDefaultValues(Mockito.any(Resource.class))).thenReturn(either);
 226     }
 227
 228     private ResponseFormat createGeneralErrorInfo() {
 229         ResponseFormat responseFormat = new ResponseFormat(500);
 230         responseFormat.setPolicyException(new PolicyException("POL5000", "Error: Internal Server Error. Please try again later", null));
 231         return responseFormat;
 232     }
 233
 234     private UploadResourceInfo createDummyResourceMD() {
 235         UploadResourceInfo resourceMD = new UploadResourceInfo();
 236         resourceMD.setName("tosca.nodes.BlockStorage");
 237         resourceMD.setPayloadName("payLoad");
 238         resourceMD.addSubCategory("Generic", "Infrastructure");
 239         resourceMD.setContactId("ya107f");
 240         resourceMD.setResourceIconPath("defaulticon");
 241         resourceMD.setTags(Collections.singletonList("BlockStorage"));
 242         resourceMD.setDescription("Represents a server-local block storage device (i.e., not shared) offering evenly sized blocks of data from which raw storage volumes can be created.");
 243         resourceMD.setResourceVendorModelNumber("vendorReleaseNumber");
 244         return resourceMD;
 245     }
 246
 247     private void testSetProperties(Resource resource) {
 248         List<PropertyDefinition> propertiesList = resource.getProperties();
 249
 250         Map<String, PropertyDefinition> properties = new HashMap<>();
 251         for (PropertyDefinition propertyDefinition : propertiesList) {
 252             properties.put(propertyDefinition.getName(), propertyDefinition);
 253         }
 254
 255         assertEquals(3, properties.size());
 256         assertTrue(properties.containsKey("size"));
 257         PropertyDefinition propertyDefinition = properties.get("size");
 258         assertEquals("scalar-unit.size", propertyDefinition.getType());
 259         assertEquals(1, propertyDefinition.getConstraints().size());
 260         PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
 261         assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
 262
 263         assertTrue(properties.containsKey("volume_id"));
 264         propertyDefinition = properties.get("volume_id");
 265         assertEquals("string", propertyDefinition.getType());
 266         assertTrue(!propertyDefinition.isRequired());
 267
 268         assertTrue(properties.containsKey("snapshot_id"));
 269         propertyDefinition = properties.get("snapshot_id");
 270         assertEquals("string", propertyDefinition.getType());
 271         assertTrue(!propertyDefinition.isRequired());
 272
 273     }
 274
 275     private void testSetCapabilities(Resource resource) {
 276         Map<String, List<CapabilityDefinition>> capabilities = resource.getCapabilities();
 277         assertEquals(3, capabilities.size());
 278         assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint"));
 279         List<CapabilityDefinition> capabilityList = capabilities.get("tosca.capabilities.Endpoint");
 280         CapabilityDefinition capability = capabilityList.get(0);
 281         assertEquals("tosca.capabilities.Endpoint", capability.getType());
 282         assertEquals("data_endpoint", capability.getName());
 283
 284         assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint.Admin"));
 285         capabilityList = capabilities.get("tosca.capabilities.Endpoint.Admin");
 286         capability = capabilityList.get(0);
 287         assertEquals("tosca.capabilities.Endpoint.Admin", capability.getType());
 288         assertEquals("admin_endpoint", capability.getName());
 289
 290         assertTrue(capabilities.containsKey("tosca.capabilities.Container"));
 291         capabilityList = capabilities.get("tosca.capabilities.Container");
 292         capability = capabilityList.get(0);
 293         assertEquals("tosca.capabilities.Container", capability.getType());
 294         assertEquals("host", capability.getName());
 295
 296         List<String> validSourceTypes = capability.getValidSourceTypes();
 297         assertEquals(1, validSourceTypes.size());
 298         assertEquals("tosca.nodes.WebApplication", validSourceTypes.get(0));
 299
 300     }
 301
 302     private void testSetRequirments(Resource resource) {
 303         Map<String, List<RequirementDefinition>> requirements = resource.getRequirements();
 304         assertEquals(2, requirements.size());
 305
 306         assertTrue(requirements.containsKey("tosca.capabilities.network.Linkable"));
 307         List<RequirementDefinition> requirementList = requirements.get("tosca.capabilities.network.Linkable");
 308         RequirementDefinition requirement = requirementList.get(0);
 309         assertEquals("tosca.capabilities.network.Linkable", requirement.getCapability());
 310         assertEquals("tosca.relationships.network.LinksTo", requirement.getRelationship());
 311         assertEquals("link", requirement.getName());
 312
 313         assertTrue(requirements.containsKey("tosca.capabilities.network.Bindable"));
 314         requirementList = requirements.get("tosca.capabilities.network.Bindable");
 315         requirement = requirementList.get(0);
 316         assertEquals("tosca.capabilities.network.Bindable", requirement.getCapability());
 317         assertEquals("tosca.relationships.network.BindsTo", requirement.getRelationship());
 318         assertEquals("binding", requirement.getName());
 319
 320     }
 321
 322     private void testSetDerivedFrom(Resource resource) {
 323         assertEquals(1, resource.getDerivedFrom().size());
 324         assertEquals("tosca.nodes.Root", resource.getDerivedFrom().get(0));
 325
 326     }
 327
 328     private void testSetMetaDataFromJson(Resource resource, UploadResourceInfo resourceMD) {
 329
 330         // assertTrue( resource.getCategory().equals(resourceMD.getCategory())
 331         // );
 332         assertEquals(resource.getDescription(), resourceMD.getDescription());
 333         assertEquals(resource.getIcon(), resourceMD.getResourceIconPath());
 334         assertEquals(resource.getName(), resourceMD.getName());
 335         assertEquals(resource.getResourceVendorModelNumber(), resourceMD.getResourceVendorModelNumber());
 336         assertEquals(resource.getContactId(), resourceMD.getContactId());
 337         assertEquals(resource.getCreatorUserId(), resourceMD.getContactId());
 338
 339         // assertTrue( resource.isAbstract() ==
 340         // Constants.ABSTRACT_CATEGORY.equals(resourceMD.getCategory()));
 341
 342         assertEquals(resourceMD.getTags().size(), resource.getTags().size());
 343         for (String tag : resource.getTags()) {
 344             assertTrue(resourceMD.getTags().contains(tag));
 345         }
 346
 347     }
 348
 349     private void testSetConstantMetaData(Resource resource) {
 350         assertEquals(resource.getVersion(), TypeUtils.getFirstCertifiedVersionVersion());
 351         assertSame(resource.getLifecycleState(), ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE);
 352         assertEquals(resource.isHighestVersion(), ImportUtils.Constants.NORMATIVE_TYPE_HIGHEST_VERSION);
 353         assertEquals(resource.getVendorName(), ImportUtils.Constants.VENDOR_NAME);
 354         assertEquals(resource.getVendorRelease(), ImportUtils.Constants.VENDOR_RELEASE);
 355     }
 356
 357 }