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 static org.junit.jupiter.api.Assertions.assertEquals;
  26 import static org.junit.jupiter.api.Assertions.assertFalse;
  27 import static org.junit.jupiter.api.Assertions.assertNotNull;
  28 import static org.junit.jupiter.api.Assertions.assertNull;
  29 import static org.junit.jupiter.api.Assertions.assertSame;
  30 import static org.junit.jupiter.api.Assertions.assertThrows;
  31 import static org.junit.jupiter.api.Assertions.assertTrue;
  32 import static org.mockito.ArgumentMatchers.any;
  33 import static org.mockito.ArgumentMatchers.anyString;
  34 import static org.mockito.ArgumentMatchers.eq;
  35 import static org.mockito.Mockito.when;
  36
  37 import java.io.IOException;
  38 import java.util.Collections;
  39 import java.util.HashMap;
  40 import java.util.List;
  41 import java.util.Map;
  42
  43 import org.apache.commons.lang3.StringUtils;
  44 import org.apache.commons.lang3.tuple.ImmutablePair;
  45 import org.junit.jupiter.api.BeforeAll;
  46 import org.junit.jupiter.api.BeforeEach;
  47 import org.junit.jupiter.api.Test;
  48 import org.mockito.Mockito;
  49 import org.mockito.stubbing.Answer;
  50 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  51 import org.openecomp.sdc.be.components.impl.ImportUtils;
  52 import org.openecomp.sdc.be.components.impl.ImportUtilsTest;
  53 import org.openecomp.sdc.be.components.impl.InterfaceDefinitionHandler;
  54 import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic;
  55 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
  56 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
  57 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  58 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  59 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  60 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
  61 import org.openecomp.sdc.be.config.Configuration;
  62 import org.openecomp.sdc.be.config.ConfigurationManager;
  63 import org.openecomp.sdc.be.dao.api.ActionStatus;
  64 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  65 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  66 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  67 import org.openecomp.sdc.be.impl.ComponentsUtils;
  68 import org.openecomp.sdc.be.model.CapabilityDefinition;
  69 import org.openecomp.sdc.be.model.Component;
  70 import org.openecomp.sdc.be.model.InterfaceDefinition;
  71 import org.openecomp.sdc.be.model.PropertyConstraint;
  72 import org.openecomp.sdc.be.model.PropertyDefinition;
  73 import org.openecomp.sdc.be.model.RequirementDefinition;
  74 import org.openecomp.sdc.be.model.Resource;
  75 import org.openecomp.sdc.be.model.UploadResourceInfo;
  76 import org.openecomp.sdc.be.model.User;
  77 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  78 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  79 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
  80 import org.openecomp.sdc.be.model.tosca.constraints.GreaterOrEqualConstraint;
  81 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  82 import org.openecomp.sdc.be.tosca.utils.InterfaceTypesNameUtil;
  83 import org.openecomp.sdc.be.user.UserBusinessLogic;
  84 import org.openecomp.sdc.be.utils.TypeUtils;
  85 import org.openecomp.sdc.common.api.ConfigurationSource;
  86 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  87 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  88 import org.openecomp.sdc.exception.PolicyException;
  89 import org.openecomp.sdc.exception.ResponseFormat;
  90
  91 import fj.data.Either;
  92
  93 public class ResourceImportManagerTest {
  94
  95     static ResourceImportManager importManager;
  96     static AuditingManager auditingManager = Mockito.mock(AuditingManager.class);
  97     static ResponseFormatManager responseFormatManager = Mockito.mock(ResponseFormatManager.class);
  98     static ResourceBusinessLogic resourceBusinessLogic = Mockito.mock(ResourceBusinessLogic.class);
  99     static InterfaceOperationBusinessLogic interfaceOperationBusinessLogic = Mockito.mock(InterfaceOperationBusinessLogic.class);
 100     static InterfaceDefinitionHandler interfaceDefinitionHandler =
 101         new InterfaceDefinitionHandler(interfaceOperationBusinessLogic);
 102
 103     static UserBusinessLogic userAdmin = Mockito.mock(UserBusinessLogic.class);
 104     static ToscaOperationFacade toscaOperationFacade =  Mockito.mock(ToscaOperationFacade.class);
 105
 106     protected static final ComponentsUtils componentsUtils = Mockito.mock(ComponentsUtils.class);
 107     private static final CapabilityTypeOperation capabilityTypeOperation = Mockito.mock(CapabilityTypeOperation.class);
 108
 109     @BeforeAll
 110     public static void beforeClass() {
 111         importManager = new ResourceImportManager(componentsUtils, capabilityTypeOperation, interfaceDefinitionHandler);
 112         importManager.setAuditingManager(auditingManager);
 113         when(toscaOperationFacade.getLatestByToscaResourceName(Mockito.anyString())).thenReturn(Either.left(null));
 114         when(toscaOperationFacade.getLatestByToscaResourceNameAndModel(Mockito.anyString(), Mockito.any())).thenReturn(Either.left(null));
 115         importManager.setResponseFormatManager(responseFormatManager);
 116         importManager.setResourceBusinessLogic(resourceBusinessLogic);
 117         importManager.setToscaOperationFacade(toscaOperationFacade);
 118
 119         String appConfigDir = "src/test/resources/config/catalog-be";
 120         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
 121         final ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 122
 123         Configuration configuration = new Configuration();
 124         configuration.setJanusGraphInMemoryGraph(true);
 125         configurationManager.setConfiguration(configuration);
 126     }
 127
 128     @BeforeEach
 129     public void beforeTest() {
 130         Mockito.reset(auditingManager, responseFormatManager, resourceBusinessLogic, userAdmin);
 131         Either<Component, StorageOperationStatus> notFound = Either.right(StorageOperationStatus.NOT_FOUND);
 132         when(toscaOperationFacade.getComponentByNameAndVendorRelease(any(ComponentTypeEnum.class), anyString(), anyString(),
 133             any(JsonParseFlagEnum.class))).thenReturn(notFound);
 134     }
 135
 136     @Test
 137     void testBasicResourceCreation() throws IOException {
 138         UploadResourceInfo resourceMD = createDummyResourceMD();
 139
 140         User user = new User();
 141         user.setUserId(resourceMD.getContactId());
 142         user.setRole("ADMIN");
 143         user.setFirstName("Jhon");
 144         user.setLastName("Doh");
 145         when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(user);
 146
 147         setResourceBusinessLogicMock();
 148
 149         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
 150
 151         ImmutablePair<Resource, ActionStatus> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
 152         Resource resource = createResource.left;
 153
 154         testSetConstantMetaData(resource);
 155         testSetMetaDataFromJson(resource, resourceMD);
 156
 157         testSetDerivedFrom(resource);
 158         testSetProperties(resource);
 159
 160         Mockito.verify(resourceBusinessLogic, Mockito.times(1)).propagateStateToCertified(eq(user), eq(resource), Mockito.any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
 161     }
 162
 163     @Test()
 164     void testResourceCreationFailed() {
 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         ResponseFormat dummyResponseFormat = createGeneralErrorInfo();
 170
 171         when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(dummyResponseFormat);
 172         setResourceBusinessLogicMock();
 173
 174         String jsonContent = "this is an invalid yml!";
 175         ComponentException errorInfoFromTest = null;
 176         try {
 177             importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
 178         }catch (ComponentException e){
 179             errorInfoFromTest = e;
 180         }
 181         assertNotNull(errorInfoFromTest);
 182         assertEquals(ActionStatus.GENERAL_ERROR, errorInfoFromTest.getActionStatus());
 183
 184         Mockito.verify(resourceBusinessLogic, Mockito.times(0)).createOrUpdateResourceByImport(Mockito.any(Resource.class), eq(user), eq(true), eq(false), eq(true), eq(null), eq(null), eq(false));
 185         Mockito.verify(resourceBusinessLogic, Mockito.times(0)).propagateStateToCertified(eq(user), Mockito.any(Resource.class), Mockito.any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
 186     }
 187
 188     @Test
 189     void testResourceCreationWithCapabilities() throws IOException {
 190         UploadResourceInfo resourceMD = createDummyResourceMD();
 191         User user = new User();
 192         user.setUserId(resourceMD.getContactId());
 193         when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(user);
 194
 195         setResourceBusinessLogicMock();
 196
 197         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
 198
 199         ImmutablePair<Resource, ActionStatus> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
 200         Resource resource = createResource.left;
 201         testSetCapabilities(resource);
 202
 203         Mockito.verify(resourceBusinessLogic, Mockito.times(1)).propagateStateToCertified(eq(user), eq(resource), Mockito.any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
 204         Mockito.verify(resourceBusinessLogic, Mockito.times(1)).createOrUpdateResourceByImport(resource, user, true, false, true, null, null, false);
 205
 206     }
 207
 208     @Test
 209     void testResourceCreationWithRequirments() throws IOException {
 210         UploadResourceInfo resourceMD = createDummyResourceMD();
 211         User user = new User();
 212         user.setUserId(resourceMD.getContactId());
 213         when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(user);
 214
 215         setResourceBusinessLogicMock();
 216
 217         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-port.yml");
 218
 219         ImmutablePair<Resource, ActionStatus> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
 220         testSetRequirments(createResource.left);
 221
 222     }
 223
 224     @Test
 225     void testResourceCreationWithInterfaceImplementation() throws IOException {
 226         UploadResourceInfo resourceMD = createDummyResourceMD();
 227         User user = new User();
 228         user.setUserId(resourceMD.getContactId());
 229         when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(user);
 230
 231         setResourceBusinessLogicMock();
 232
 233         String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl.yml");
 234
 235         Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
 236         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 237         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 238         Map<String, OperationDataDefinition> operations = new HashMap<>();
 239         operations.put("configure", new OperationDataDefinition());
 240                 interfaceDefinition.setOperations(operations );
 241         interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
 242                 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
 243
 244         final ImmutablePair<Resource, ActionStatus> createResource = importManager
 245             .importNormativeResource(jsonContent, resourceMD, user, true, true);
 246         assertSetInterfaceImplementation(createResource.left);
 247     }
 248
 249     @Test
 250     void testResourceCreationWithInterfaceImplementation_UnknownInterface() throws IOException {
 251         UploadResourceInfo resourceMD = createDummyResourceMD();
 252         User user = new User();
 253         user.setUserId(resourceMD.getContactId());
 254         when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(user);
 255
 256         setResourceBusinessLogicMock();
 257
 258         String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-unknown-interface-impl.yml");
 259
 260         Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
 261         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 262         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 263         Map<String, OperationDataDefinition> operations = new HashMap<>();
 264         operations.put("configure", new OperationDataDefinition());
 265                 interfaceDefinition.setOperations(operations );
 266         interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
 267                 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
 268
 269         ImmutablePair<Resource, ActionStatus> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
 270         assertNull(createResource.left.getInterfaces());
 271     }
 272
 273     @Test
 274     void testResourceCreationWitInterfaceImplementation_UnknownOperation() throws IOException {
 275         UploadResourceInfo resourceMD = createDummyResourceMD();
 276         User user = new User();
 277         user.setUserId(resourceMD.getContactId());
 278         when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(user);
 279
 280         setResourceBusinessLogicMock();
 281
 282         String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl-unknown-operation.yml");
 283
 284         Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
 285         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 286         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 287         Map<String, OperationDataDefinition> operations = new HashMap<>();
 288         operations.put("configure", new OperationDataDefinition());
 289                 interfaceDefinition.setOperations(operations );
 290         interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
 291                 when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
 292
 293         ImmutablePair<Resource, ActionStatus> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
 294         assertNull(createResource.left.getInterfaces());
 295     }
 296
 297     @Test
 298     void testResourceCreationFailedVendorReleaseAlreadyExists() throws IOException {
 299         UploadResourceInfo resourceMD = createDummyResourceMD();
 300
 301         User user = new User();
 302         user.setUserId(resourceMD.getContactId());
 303         user.setRole("ADMIN");
 304         user.setFirstName("Jhon");
 305         user.setLastName("Doh");
 306         when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(user);
 307
 308         setResourceBusinessLogicMock();
 309         final Either<Component, StorageOperationStatus> foundResourceEither = Either.left(Mockito.mock(Resource.class));
 310         when(toscaOperationFacade.getComponentByNameAndVendorRelease(any(ComponentTypeEnum.class), anyString(), anyString(),
 311             any(JsonParseFlagEnum.class))).thenReturn(foundResourceEither);
 312         when(toscaOperationFacade.isNodeAssociatedToModel(eq(null), any(Resource.class))).thenReturn(true);
 313
 314         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
 315
 316         var actualException = assertThrows(ByActionStatusComponentException.class,
 317             () -> importManager.importNormativeResource(jsonContent, resourceMD, user, true, true));
 318         assertEquals(ActionStatus.COMPONENT_WITH_VENDOR_RELEASE_ALREADY_EXISTS, actualException.getActionStatus());
 319     }
 320
 321     private void setResourceBusinessLogicMock() {
 322         when(resourceBusinessLogic.getUserAdmin()).thenReturn(userAdmin);
 323         when(resourceBusinessLogic.createOrUpdateResourceByImport(Mockito.any(Resource.class), Mockito.any(User.class), Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.anyBoolean(), eq(null), eq(null), eq(false)))
 324                 .thenAnswer((Answer<ImmutablePair<Resource, ActionStatus>>) invocation -> {
 325                     Object[] args = invocation.getArguments();
 326                     return new ImmutablePair<>((Resource) args[0], ActionStatus.CREATED);
 327
 328                 });
 329         when(resourceBusinessLogic.propagateStateToCertified(Mockito.any(User.class), Mockito.any(Resource.class), Mockito.any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false)))
 330                 .thenAnswer((Answer<Resource>) invocation -> {
 331                     Object[] args = invocation.getArguments();
 332                     return (Resource) args[1];
 333
 334                 });
 335         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 -> {
 336             Object[] args = invocation.getArguments();
 337             return Either.left((Resource) args[0]);
 338
 339         });
 340         when(resourceBusinessLogic.validateResourceBeforeCreate(Mockito.any(Resource.class), Mockito.any(User.class), Mockito.any(AuditingActionEnum.class), eq(false), eq(null))).thenAnswer((Answer<Either<Resource, ResponseFormat>>) invocation -> {
 341             Object[] args = invocation.getArguments();
 342             return Either.left((Resource) args[0]);
 343
 344         });
 345
 346         Boolean either = true;
 347         when(resourceBusinessLogic.validatePropertiesDefaultValues(Mockito.any(Resource.class))).thenReturn(either);
 348     }
 349
 350     private ResponseFormat createGeneralErrorInfo() {
 351         ResponseFormat responseFormat = new ResponseFormat(500);
 352         responseFormat.setPolicyException(new PolicyException("POL5000", "Error: Internal Server Error. Please try again later", null));
 353         return responseFormat;
 354     }
 355
 356     private UploadResourceInfo createDummyResourceMD() {
 357         UploadResourceInfo resourceMD = new UploadResourceInfo();
 358         resourceMD.setName("tosca.nodes.BlockStorage");
 359         resourceMD.setPayloadName("payLoad");
 360         resourceMD.addSubCategory("Generic", "Infrastructure");
 361         resourceMD.setContactId("ya107f");
 362         resourceMD.setResourceIconPath("defaulticon");
 363         resourceMD.setTags(Collections.singletonList("BlockStorage"));
 364         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.");
 365         resourceMD.setResourceVendorModelNumber("vendorReleaseNumber");
 366         return resourceMD;
 367     }
 368
 369     private void testSetProperties(Resource resource) {
 370         List<PropertyDefinition> propertiesList = resource.getProperties();
 371
 372         Map<String, PropertyDefinition> properties = new HashMap<>();
 373         for (PropertyDefinition propertyDefinition : propertiesList) {
 374             properties.put(propertyDefinition.getName(), propertyDefinition);
 375         }
 376
 377         assertEquals(3, properties.size());
 378         assertTrue(properties.containsKey("size"));
 379         PropertyDefinition propertyDefinition = properties.get("size");
 380         assertEquals("scalar-unit.size", propertyDefinition.getType());
 381         assertEquals(1, propertyDefinition.getConstraints().size());
 382         PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
 383         assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
 384
 385         assertTrue(properties.containsKey("volume_id"));
 386         propertyDefinition = properties.get("volume_id");
 387         assertEquals("string", propertyDefinition.getType());
 388         assertFalse(propertyDefinition.isRequired());
 389
 390         assertTrue(properties.containsKey("snapshot_id"));
 391         propertyDefinition = properties.get("snapshot_id");
 392         assertEquals("string", propertyDefinition.getType());
 393         assertFalse(propertyDefinition.isRequired());
 394
 395     }
 396
 397     private void testSetCapabilities(Resource resource) {
 398         Map<String, List<CapabilityDefinition>> capabilities = resource.getCapabilities();
 399         assertEquals(3, capabilities.size());
 400         assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint"));
 401         List<CapabilityDefinition> capabilityList = capabilities.get("tosca.capabilities.Endpoint");
 402         CapabilityDefinition capability = capabilityList.get(0);
 403         assertEquals("tosca.capabilities.Endpoint", capability.getType());
 404         assertEquals("data_endpoint", capability.getName());
 405
 406         assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint.Admin"));
 407         capabilityList = capabilities.get("tosca.capabilities.Endpoint.Admin");
 408         capability = capabilityList.get(0);
 409         assertEquals("tosca.capabilities.Endpoint.Admin", capability.getType());
 410         assertEquals("admin_endpoint", capability.getName());
 411
 412         assertTrue(capabilities.containsKey("tosca.capabilities.Container"));
 413         capabilityList = capabilities.get("tosca.capabilities.Container");
 414         capability = capabilityList.get(0);
 415         assertEquals("tosca.capabilities.Container", capability.getType());
 416         assertEquals("host", capability.getName());
 417
 418         List<String> validSourceTypes = capability.getValidSourceTypes();
 419         assertEquals(1, validSourceTypes.size());
 420         assertEquals("tosca.nodes.WebApplication", validSourceTypes.get(0));
 421
 422     }
 423
 424     private void testSetRequirments(Resource resource) {
 425         Map<String, List<RequirementDefinition>> requirements = resource.getRequirements();
 426         assertEquals(2, requirements.size());
 427
 428         assertTrue(requirements.containsKey("tosca.capabilities.network.Linkable"));
 429         List<RequirementDefinition> requirementList = requirements.get("tosca.capabilities.network.Linkable");
 430         RequirementDefinition requirement = requirementList.get(0);
 431         assertEquals("tosca.capabilities.network.Linkable", requirement.getCapability());
 432         assertEquals("tosca.relationships.network.LinksTo", requirement.getRelationship());
 433         assertEquals("link", requirement.getName());
 434
 435         assertTrue(requirements.containsKey("tosca.capabilities.network.Bindable"));
 436         requirementList = requirements.get("tosca.capabilities.network.Bindable");
 437         requirement = requirementList.get(0);
 438         assertEquals("tosca.capabilities.network.Bindable", requirement.getCapability());
 439         assertEquals("tosca.relationships.network.BindsTo", requirement.getRelationship());
 440         assertEquals("binding", requirement.getName());
 441
 442     }
 443
 444     private void assertSetInterfaceImplementation(final Resource resource) {
 445         final Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
 446         assertNotNull(interfaces);
 447         assertEquals(1, interfaces.size());
 448         final InterfaceDefinition interfaceDefinition = interfaces.get("Standard");
 449         assertTrue(interfaces.containsKey(InterfaceTypesNameUtil.buildShortName(interfaceDefinition.getType())));
 450         Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
 451         operations.values().forEach(operationDataDefinition ->
 452             assertTrue(operations.containsKey(operationDataDefinition.getName())));
 453     }
 454
 455     private void testSetDerivedFrom(Resource resource) {
 456         assertEquals(1, resource.getDerivedFrom().size());
 457         assertEquals("tosca.nodes.Root", resource.getDerivedFrom().get(0));
 458
 459     }
 460
 461     private void testSetMetaDataFromJson(Resource resource, UploadResourceInfo resourceMD) {
 462         assertEquals(resource.getDescription(), resourceMD.getDescription());
 463         assertEquals(resource.getIcon(), resourceMD.getResourceIconPath());
 464         assertEquals(resource.getName(), resourceMD.getName());
 465         assertEquals(resource.getResourceVendorModelNumber(), resourceMD.getResourceVendorModelNumber());
 466         assertEquals(resource.getContactId(), resourceMD.getContactId());
 467         assertEquals(resource.getCreatorUserId(), resourceMD.getContactId());
 468         assertEquals(resourceMD.getTags().size(), resource.getTags().size());
 469         for (String tag : resource.getTags()) {
 470             assertTrue(resourceMD.getTags().contains(tag));
 471         }
 472
 473     }
 474
 475     private void testSetConstantMetaData(Resource resource) {
 476         assertEquals(resource.getVersion(), TypeUtils.getFirstCertifiedVersionVersion());
 477         assertSame(ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE, resource.getLifecycleState());
 478         assertEquals(ImportUtils.Constants.NORMATIVE_TYPE_HIGHEST_VERSION, resource.isHighestVersion());
 479         assertEquals(ImportUtils.Constants.VENDOR_NAME, resource.getVendorName());
 480         assertEquals(ImportUtils.Constants.VENDOR_RELEASE, resource.getVendorRelease());
 481     }
 482
 483 }