gerrit.onap Code Review - sdc.git/blob

   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.model.operations.impl;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertTrue;
  25
  26 import java.io.BufferedOutputStream;
  27 import java.io.File;
  28 import java.io.FileOutputStream;
  29 import java.io.OutputStream;
  30 import java.util.ArrayList;
  31 import java.util.Collection;
  32 import java.util.HashMap;
  33 import java.util.Iterator;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.Map.Entry;
  37 import java.util.Set;
  38 import java.util.UUID;
  39 import java.util.function.Function;
  40 import java.util.stream.Collectors;
  41
  42 import javax.annotation.Resource;
  43
  44 import org.apache.tinkerpop.gremlin.structure.io.IoCore;
  45 import org.junit.Before;
  46 import org.junit.BeforeClass;
  47 import org.junit.Ignore;
  48 import org.junit.Test;
  49 import org.junit.runner.RunWith;
  50 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  51 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  52 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  53 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
  54 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  55 import org.openecomp.sdc.be.model.CapabilityDefinition;
  56 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  57 import org.openecomp.sdc.be.model.ComponentInstance;
  58 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  59 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  60 import org.openecomp.sdc.be.model.ModelTestBase;
  61 import org.openecomp.sdc.be.model.PropertyConstraint;
  62 import org.openecomp.sdc.be.model.PropertyDefinition;
  63 import org.openecomp.sdc.be.model.Service;
  64 import org.openecomp.sdc.be.model.User;
  65 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  66 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  67 import org.openecomp.sdc.be.model.operations.impl.CapabilityOperation;
  68 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
  69 import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
  70 import org.openecomp.sdc.be.model.operations.impl.LifecycleOperation;
  71 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  72 import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
  73 import org.openecomp.sdc.be.model.operations.impl.ServiceOperation;
  74 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  75 import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
  76 import org.openecomp.sdc.be.model.operations.impl.util.ResourceCreationUtils;
  77 import org.openecomp.sdc.be.model.tosca.ToscaType;
  78 import org.openecomp.sdc.be.model.tosca.constraints.GreaterThanConstraint;
  79 import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
  80 import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
  81 import org.openecomp.sdc.be.resources.data.CapabilityData;
  82 import org.openecomp.sdc.be.resources.data.CapabilityInstData;
  83 import org.openecomp.sdc.be.resources.data.PropertyValueData;
  84 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  85 import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
  86 import org.openecomp.sdc.be.resources.data.UserData;
  87 import org.openecomp.sdc.be.unittests.utils.FactoryUtils;
  88 import org.openecomp.sdc.be.unittests.utils.FactoryUtils.Constants;
  89 import org.slf4j.Logger;
  90 import org.slf4j.LoggerFactory;
  91 import org.springframework.test.context.ContextConfiguration;
  92 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  93
  94 import com.google.gson.Gson;
  95 import com.google.gson.GsonBuilder;
  96 import com.thinkaurelius.titan.core.TitanGraph;
  97 import com.thinkaurelius.titan.core.TitanVertex;
  98
  99 import fj.data.Either;
 100
 101 @RunWith(SpringJUnit4ClassRunner.class)
 102 @ContextConfiguration("classpath:application-context-test.xml")
 103 public class ComponentInstanceOperationSpringTest extends ModelTestBase {
 104         private static Logger log = LoggerFactory.getLogger(ComponentInstanceOperationSpringTest.class.getName());
 105         @Resource(name = "component-instance-operation")
 106         private ComponentInstanceOperation componentInstanceOperation;
 107
 108         @Resource(name = "component-instance-operation")
 109         private ComponentInstanceOperation resourceInstanceOperation;
 110
 111         @Resource(name = "capability-type-operation")
 112         private CapabilityTypeOperation capabilityTypeOperation;
 113
 114         @Resource(name = "capability-operation")
 115         public CapabilityOperation capabilityOperation;
 116
 117         @Resource(name = "service-operation")
 118         private ServiceOperation serviceOperation;
 119
 120         @Resource(name = "resource-operation")
 121         private ResourceOperation resourceOperation;
 122
 123         @Resource(name = "property-operation")
 124         private PropertyOperation propertyOperation;
 125
 126         @Resource(name = "lifecycle-operation")
 127         private LifecycleOperation lifecycleOperation;
 128
 129         TitanGenericDao titanGenericDao;
 130
 131         private static String CATEGORY_NAME = "category/mycategory";
 132
 133         User rfcUser;
 134
 135         @BeforeClass
 136         public static void setupBeforeClass() {
 137                 ModelTestBase.init();
 138
 139         }
 140
 141         @Before
 142         public void cleanUp() {
 143                 titanGenericDao = componentInstanceOperation.titanGenericDao;
 144                 Either<TitanGraph, TitanOperationStatus> graphResult = titanGenericDao.getGraph();
 145                 TitanGraph graph = graphResult.left().value();
 146
 147                 Iterable<TitanVertex> vertices = graph.query().vertices();
 148                 if (vertices != null) {
 149                         Iterator<TitanVertex> iterator = vertices.iterator();
 150                         while (iterator.hasNext()) {
 151                                 TitanVertex vertex = iterator.next();
 152                                 vertex.remove();
 153                         }
 154
 155                 }
 156                 titanGenericDao.commit();
 157                 deleteAndCreateCategory(CATEGORY_NAME);
 158                 UserData modifierData = deleteAndCreateUser(ResourceCreationUtils.MODIFIER_ATT_UID + "rfc", ResourceCreationUtils.MODIFIER_FIRST_NAME, ResourceCreationUtils.MODIFIER_LAST_NAME, "ADMIN");
 159                 rfcUser = convertUserDataToUser(modifierData);
 160         }
 161
 162         @Test
 163         @Ignore
 164         public void testAddCapabilityPropertyValuesToResourceInstance() {
 165                 String rootName = "Root123";
 166                 org.openecomp.sdc.be.model.Resource rootResource = createResource(rfcUser.getUserId(), CATEGORY_NAME, rootName, "1.0", null, false, true);
 167
 168                 // certification request
 169                 Either<? extends org.openecomp.sdc.be.model.Component, StorageOperationStatus> requestCertificationResult = lifecycleOperation.requestCertificationComponent(NodeTypeEnum.Resource, rootResource, rfcUser, rfcUser, false);
 170                 assertTrue(requestCertificationResult.isLeft());
 171
 172                 org.openecomp.sdc.be.model.Resource resultResource = (org.openecomp.sdc.be.model.Resource) requestCertificationResult.left().value();
 173
 174                 // start certification
 175                 Either<? extends org.openecomp.sdc.be.model.Component, StorageOperationStatus> startCertificationResult = lifecycleOperation.startComponentCertification(NodeTypeEnum.Resource, resultResource, rfcUser, rfcUser, false);
 176                 assertEquals(true, startCertificationResult.isLeft());
 177
 178                 Either<? extends org.openecomp.sdc.be.model.Component, StorageOperationStatus> certifiedResourceRes = lifecycleOperation.certifyComponent(NodeTypeEnum.Resource, rootResource, rfcUser, rfcUser, false);
 179                 assertTrue(certifiedResourceRes.isLeft());
 180
 181                 CapabilityTypeDefinition capabilityType = buildCapabilityType();
 182                 Either<CapabilityTypeDefinition, StorageOperationStatus> capabilityTypeRes = capabilityTypeOperation.addCapabilityType(capabilityType);
 183                 assertTrue(capabilityTypeRes.isLeft());
 184
 185                 CapabilityData capData = FactoryUtils.createCapabilityData();
 186                 CapabilityDefinition capabilityDefinitionRoot = FactoryUtils.convertCapabilityDataToCapabilityDefinitionRoot(capData);
 187
 188                 Either<CapabilityDefinition, StorageOperationStatus> addCapabilityRootRes = capabilityOperation.addCapability((String) certifiedResourceRes.left().value().getUniqueId(), capabilityDefinitionRoot.getName(), capabilityDefinitionRoot);
 189                 assertTrue(addCapabilityRootRes.isLeft());
 190
 191                 String resourceName = "tosca.nodes.Apache.2.0";
 192
 193                 CapabilityDefinition capabilityDefinition = FactoryUtils.convertCapabilityDataToCapabilityDefinitionAddProperties(capData);
 194                 org.openecomp.sdc.be.model.Resource resource = createResource(rfcUser.getUserId(), CATEGORY_NAME, resourceName, "0.1", rootName, false, true);
 195
 196                 Either<CapabilityDefinition, StorageOperationStatus> addCapabilityRes = capabilityOperation.addCapability((String) resource.getUniqueId(), capabilityDefinition.getName(), capabilityDefinition);
 197                 assertTrue(addCapabilityRes.isLeft());
 198                 List<ComponentInstanceProperty> properties = addCapabilityRes.left().value().getProperties();
 199                 assertTrue(properties.size() == 2);
 200
 201                 Either<org.openecomp.sdc.be.model.Resource, StorageOperationStatus> clonedResourceRes = resourceOperation.cloneComponent(resource, "0.2", false);
 202                 assertTrue(clonedResourceRes.isLeft());
 203                 org.openecomp.sdc.be.model.Resource clonedResource = clonedResourceRes.left().value();
 204
 205                 ComponentInstance instance = buildResourceInstance(clonedResource.getUniqueId(), "1", "tosca.nodes.Apache");
 206
 207                 Service origService = createService(rfcUser.getUserId(), CATEGORY_NAME, "my-service", "1.0", true);
 208                 Either<Service, StorageOperationStatus> service2 = serviceOperation.getService(origService.getUniqueId(), false);
 209                 assertTrue(service2.isLeft());
 210                 origService = service2.left().value();
 211
 212                 Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
 213                 String json = prettyGson.toJson(origService);
 214                 log.debug(json);
 215
 216                 Service fullService = origService;
 217
 218                 Either<ComponentInstance, TitanOperationStatus> status = resourceInstanceOperation.addComponentInstanceToContainerComponent((String) origService.getUniqueId(), NodeTypeEnum.Service, "1", true, instance, NodeTypeEnum.Resource, false);
 219                 assertTrue(status.isLeft());
 220
 221                 ComponentInstance resourceInstance = status.left().value();
 222                 CapabilityDefinition capability = addCapabilityRes.left().value();
 223                 capability.setName(capabilityDefinition.getName());
 224                 List<ComponentInstanceProperty> propertyValues = FactoryUtils.createComponentInstancePropertyList();
 225                 capability.setProperties(propertyValues);
 226
 227                 Either<Map<CapabilityInstData, List<PropertyValueData>>, TitanOperationStatus> addCPVsToRiRes = componentInstanceOperation.addCapabilityPropertyValuesToResourceInstance(resourceInstance.getUniqueId(), capability, true);
 228                 assertTrue(addCPVsToRiRes.isLeft());
 229
 230                 Either<Service, StorageOperationStatus> createService = serviceOperation.cloneService(fullService, "2.0", false);
 231                 assertTrue(createService.isLeft());
 232                 Map<String, List<CapabilityDefinition>> capabilitiesMap = createService.left().value().getCapabilities();
 233                 assertTrue(capabilitiesMap != null && capabilitiesMap.size() == 1);
 234                 Map<String, CapabilityDefinition> capabilities = capabilitiesMap.values().iterator().next().stream().collect(Collectors.toMap(CapabilityDefinition::getName, Function.identity()));
 235                 assertTrue(capabilities.containsKey("Cap1") && capabilities.containsKey("Cap2"));
 236
 237                 // String outputFile = exportGraphMl();
 238
 239         }
 240
 241         public String exportGraphMl() {
 242                 String result = null;
 243                 String outputFile = "C:\\Output" + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml";
 244                 TitanGraph graph = titanGenericDao.getGraph().left().value();
 245                 try {
 246                         try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) {
 247                                 graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph);
 248                         }
 249                         result = outputFile;
 250                         graph.tx().commit();
 251                 } catch (Exception e) {
 252                         graph.tx().rollback();
 253                         e.printStackTrace();
 254                 }
 255                 return result;
 256
 257         }
 258
 259         private CapabilityTypeDefinition buildCapabilityType() {
 260                 CapabilityTypeDefinition capabilityType = new CapabilityTypeDefinition();
 261                 Map<String, PropertyDefinition> properties = new HashMap();
 262
 263                 capabilityType.setType(Constants.DEFAULT_CAPABILITY_TYPE);
 264                 capabilityType.setProperties(properties);
 265
 266                 PropertyDefinition host = new PropertyDefinition();
 267                 host.setUniqueId(UUID.randomUUID().toString());
 268                 host.setName("host");
 269                 host.setDefaultValue("captypehost");
 270                 host.setType("string");
 271
 272                 host.setSchema(new SchemaDefinition());
 273                 host.getSchema().setProperty(new PropertyDataDefinition());
 274                 host.getSchema().getProperty().setType("string");
 275
 276                 PropertyDefinition port = new PropertyDefinition();
 277                 port.setName("port");
 278                 port.setDefaultValue("captypeport");
 279                 port.setUniqueId(UUID.randomUUID().toString());
 280                 port.setType("string");
 281
 282                 port.setSchema(new SchemaDefinition());
 283                 port.getSchema().setProperty(new PropertyDataDefinition());
 284                 port.getSchema().getProperty().setType("string");
 285
 286                 PropertyDefinition rootproperty = new PropertyDefinition();
 287                 rootproperty.setName("captypeproperty");
 288                 rootproperty.setDefaultValue("captypevalue");
 289                 rootproperty.setUniqueId(UUID.randomUUID().toString());
 290                 rootproperty.setType("string");
 291
 292                 rootproperty.setSchema(new SchemaDefinition());
 293                 rootproperty.getSchema().setProperty(new PropertyDataDefinition());
 294                 rootproperty.getSchema().getProperty().setType("string");
 295
 296                 properties.put("host", host);
 297                 properties.put("port", port);
 298                 properties.put("captypeproperty", rootproperty);
 299                 return capabilityType;
 300         }
 301
 302         private CapabilityInstData buildCapabilityInstanceData(String resourceInstanceId, CapabilityDefinition capability) {
 303                 CapabilityInstData capabilityInstance = new CapabilityInstData();
 304                 Long creationTime = System.currentTimeMillis();
 305                 String uniqueId = UniqueIdBuilder.buildCapabilityInstanceUid(resourceInstanceId, capability.getName());
 306                 capabilityInstance.setCreationTime(creationTime);
 307                 capabilityInstance.setModificationTime(creationTime);
 308                 capabilityInstance.setUniqueId(uniqueId);
 309                 return capabilityInstance;
 310         }
 311
 312         private ComponentInstance buildResourceInstance(String respurceUid, String instanceNumber, String name) {
 313                 ComponentInstance resourceInstance = new ComponentInstance();
 314                 resourceInstance.setName(name);
 315                 resourceInstance.setDescription("desc1");
 316                 resourceInstance.setPosX("20");
 317                 resourceInstance.setPosY("40");
 318                 resourceInstance.setComponentUid(respurceUid);
 319                 resourceInstance.setCreationTime(System.currentTimeMillis());
 320                 resourceInstance.setModificationTime(System.currentTimeMillis());
 321                 resourceInstance.setNormalizedName(ResourceInstanceOperationTest.normaliseComponentInstanceName(name));
 322                 return resourceInstance;
 323         }
 324
 325         public ResourceMetadataData createResource(String resourceName, TitanGenericDao titanGenericDao) {
 326                 ResourceMetadataData serviceData1 = new ResourceMetadataData();
 327                 serviceData1.getMetadataDataDefinition().setUniqueId(resourceName);
 328                 Either<ResourceMetadataData, TitanOperationStatus> createNode = titanGenericDao.createNode(serviceData1, ResourceMetadataData.class);
 329                 assertTrue("check service created", createNode.isLeft());
 330                 return createNode.left().value();
 331         }
 332
 333         public ServiceMetadataData createServiceMetadataData(String serviceName, TitanGenericDao titanGenericDao) {
 334                 ServiceMetadataData serviceData1 = new ServiceMetadataData();
 335                 serviceData1.getMetadataDataDefinition().setUniqueId(serviceName);
 336                 Either<ServiceMetadataData, TitanOperationStatus> createNode = titanGenericDao.createNode(serviceData1, ServiceMetadataData.class);
 337                 assertTrue("check service created", createNode.isLeft());
 338                 return createNode.left().value();
 339         }
 340
 341         public Service createService(String userId, String category, String serviceName, String serviceVersion, boolean isHighestVersion) {
 342                 Service service = buildServiceMetadata(userId, category, serviceName, serviceVersion);
 343                 service.setHighestVersion(isHighestVersion);
 344                 Either<Service, StorageOperationStatus> result = serviceOperation.createService(service, true);
 345                 assertTrue(result.isLeft());
 346                 Service resultService = result.left().value();
 347                 assertEquals("check resource state", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, resultService.getLifecycleState());
 348                 return resultService;
 349         }
 350
 351         private Service buildServiceMetadata(String userId, String category, String serviceName, String serviceVersion) {
 352                 Service service = new Service();
 353                 service.setName(serviceName);
 354                 service.setVersion(serviceVersion);
 355                 service.setDescription("description 1");
 356                 service.setCreatorUserId(userId);
 357                 service.setContactId("contactId@sdc.com");
 358                 CategoryDefinition categoryDef = new CategoryDefinition();
 359                 categoryDef.setName(category);
 360                 List<CategoryDefinition> categories = new ArrayList<>();
 361                 categories.add(categoryDef);
 362                 service.setCategories(categories);
 363                 service.setIcon("images/my.png");
 364                 List<String> tags = new ArrayList<String>();
 365                 tags.add("TAG1");
 366                 tags.add("TAG2");
 367                 service.setTags(tags);
 368                 return service;
 369         }
 370
 371         private void deleteAndCreateCategory(String category) {
 372                 String[] names = category.split("/");
 373                 OperationTestsUtil.deleteAndCreateServiceCategory(category, titanGenericDao);
 374                 OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanGenericDao);
 375         }
 376
 377         private UserData deleteAndCreateUser(String userId, String firstName, String lastName, String role) {
 378                 UserData userData = new UserData();
 379                 userData.setUserId(userId);
 380                 userData.setFirstName(firstName);
 381                 userData.setLastName(lastName);
 382                 if (role != null && !role.isEmpty()) {
 383                         userData.setRole(role);
 384                 } else {
 385                         userData.setRole("ADMIN");
 386                 }
 387                 titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
 388                 titanGenericDao.createNode(userData, UserData.class);
 389                 titanGenericDao.commit();
 390                 return userData;
 391         }
 392
 393         public org.openecomp.sdc.be.model.Resource createResource(String userId, String category, String resourceName, String resourceVersion, String parentResourceName, boolean isAbstract, boolean isHighestVersion) {
 394
 395                 String propName1 = "disk_size";
 396                 String propName2 = "num_cpus";
 397
 398                 List<String> derivedFrom = new ArrayList<String>();
 399                 if (parentResourceName != null) {
 400                         derivedFrom.add(parentResourceName);
 401                 }
 402                 org.openecomp.sdc.be.model.Resource resource = buildResourceMetadata(userId, category, resourceName, resourceVersion);
 403
 404                 resource.setAbstract(isAbstract);
 405                 resource.setHighestVersion(isHighestVersion);
 406
 407                 Map<String, PropertyDefinition> properties = new HashMap<String, PropertyDefinition>();
 408
 409                 PropertyDefinition property1 = new PropertyDefinition();
 410                 property1.setDefaultValue("10");
 411                 property1.setDescription("Size of the local disk, in Gigabytes (GB), available to applications running on the Compute node.");
 412                 property1.setType(ToscaType.INTEGER.name().toLowerCase());
 413                 List<PropertyConstraint> constraints = new ArrayList<PropertyConstraint>();
 414                 GreaterThanConstraint propertyConstraint1 = new GreaterThanConstraint("0");
 415                 log.debug("{}", propertyConstraint1);
 416
 417                 constraints.add(propertyConstraint1);
 418
 419                 LessOrEqualConstraint propertyConstraint2 = new LessOrEqualConstraint("10");
 420                 constraints.add(propertyConstraint2);
 421
 422                 property1.setConstraints(constraints);
 423
 424                 properties.put(propName1, property1);
 425
 426                 PropertyDefinition property2 = new PropertyDefinition();
 427                 property2.setDefaultValue("2");
 428                 property2.setDescription("Number of (actual or virtual) CPUs associated with the Compute node.");
 429                 property2.setType(ToscaType.INTEGER.name().toLowerCase());
 430                 List<PropertyConstraint> constraints3 = new ArrayList<PropertyConstraint>();
 431                 List<String> range = new ArrayList<String>();
 432                 range.add("1");
 433                 range.add("4");
 434
 435                 InRangeConstraint propertyConstraint3 = new InRangeConstraint(range);
 436                 constraints3.add(propertyConstraint3);
 437                 property2.setConstraints(constraints3);
 438                 properties.put(propName2, property2);
 439
 440                 resource.setDerivedFrom(derivedFrom);
 441
 442                 resource.setProperties(convertMapToList(properties));
 443
 444                 Either<org.openecomp.sdc.be.model.Resource, StorageOperationStatus> result = resourceOperation.createResource(resource, true);
 445
 446                 assertTrue(result.isLeft());
 447                 org.openecomp.sdc.be.model.Resource resultResource = result.left().value();
 448                 assertEquals("check resource state", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, resultResource.getLifecycleState());
 449
 450                 String resourceId = resultResource.getUniqueId();
 451
 452                 Either<PropertyDefinition, StorageOperationStatus> either = propertyOperation.getPropertyOfResource(propName1, resourceId);
 453
 454                 assertTrue(either.isLeft());
 455                 PropertyDefinition propertyDefinition = either.left().value();
 456                 assertEquals("check property default value", property1.getDefaultValue(), propertyDefinition.getDefaultValue());
 457                 assertEquals("check property description", property1.getDescription(), propertyDefinition.getDescription());
 458                 assertEquals("check property type", property1.getType(), propertyDefinition.getType());
 459                 assertEquals("check property unique id", property1.getUniqueId(), propertyDefinition.getUniqueId());
 460                 assertEquals("check property consitraints size", property1.getConstraints().size(), propertyDefinition.getConstraints().size());
 461
 462                 return resultResource;
 463         }
 464
 465         private org.openecomp.sdc.be.model.Resource buildResourceMetadata(String userId, String category, String resourceName, String resourceVersion) {
 466
 467                 org.openecomp.sdc.be.model.Resource resource = new org.openecomp.sdc.be.model.Resource();
 468                 resource.setName(resourceName);
 469                 resource.setVersion(resourceVersion);
 470                 ;
 471                 resource.setDescription("description 1");
 472                 resource.setAbstract(false);
 473                 resource.setCreatorUserId(userId);
 474                 resource.setContactId("contactId@sdc.com");
 475                 resource.setVendorName("vendor 1");
 476                 resource.setVendorRelease("1.0.0");
 477                 resource.setToscaResourceName(resourceName);
 478                 String[] categoryArr = category.split("/");
 479                 resource.addCategory(categoryArr[0], categoryArr[1]);
 480                 resource.setIcon("images/my.png");
 481                 List<String> tags = new ArrayList<String>();
 482                 tags.add("TAG1");
 483                 tags.add("TAG2");
 484                 resource.setTags(tags);
 485                 return resource;
 486         }
 487
 488         public static List<PropertyDefinition> convertMapToList(Map<String, PropertyDefinition> properties) {
 489                 if (properties == null) {
 490                         return null;
 491                 }
 492
 493                 List<PropertyDefinition> definitions = new ArrayList<>();
 494                 for (Entry<String, PropertyDefinition> entry : properties.entrySet()) {
 495                         String name = entry.getKey();
 496                         PropertyDefinition propertyDefinition = entry.getValue();
 497                         propertyDefinition.setName(name);
 498                         definitions.add(propertyDefinition);
 499                 }
 500
 501                 return definitions;
 502         }
 503
 504         private User convertUserDataToUser(UserData modifierData) {
 505                 User modifier = new User();
 506                 modifier.setUserId(modifierData.getUserId());
 507                 modifier.setEmail(modifierData.getEmail());
 508                 modifier.setFirstName(modifierData.getFirstName());
 509                 modifier.setLastName(modifierData.getLastName());
 510                 modifier.setRole(modifierData.getRole());
 511                 return modifier;
 512         }
 513 }