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