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