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