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