gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.be.model.operations.impl;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertTrue;
   5 import java.io.BufferedOutputStream;
   6 import java.io.File;
   7 import java.io.FileOutputStream;
   8 import java.io.OutputStream;
   9 import java.util.ArrayList;
  10 import java.util.HashMap;
  11 import java.util.Iterator;
  12 import java.util.List;
  13 import java.util.Map;
  14
  15 import org.apache.tinkerpop.gremlin.structure.io.IoCore;
  16 import org.junit.After;
  17 import org.junit.Before;
  18 import org.junit.BeforeClass;
  19 import org.junit.Rule;
  20 import org.junit.Test;
  21 import org.junit.rules.TestName;
  22 import org.junit.runner.RunWith;
  23 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  24 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  25
  26 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  27 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  28 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  29 import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
  30 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
  31 import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition;
  32 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  33 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  34 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  35 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  36 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  37 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
  38 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  39 import org.openecomp.sdc.be.model.ModelTestBase;
  40 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  41 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  42
  43 import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType;
  44 import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate;
  45 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
  46 import org.openecomp.sdc.be.model.jsontitan.operations.NodeTypeOperation;
  47 import org.openecomp.sdc.be.model.jsontitan.operations.TopologyTemplateOperation;
  48 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaElementLifecycleOperation;
  49 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  50 import org.openecomp.sdc.common.util.ValidationUtils;
  51 import org.springframework.test.context.ContextConfiguration;
  52 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  53
  54 import com.thinkaurelius.titan.core.TitanGraph;
  55 import com.thinkaurelius.titan.core.TitanVertex;
  56
  57 import fj.data.Either;
  58
  59 @RunWith(SpringJUnit4ClassRunner.class)
  60 @ContextConfiguration("classpath:application-context-test.xml")
  61 public class ToscaElementLifecycleOperationTest extends ModelTestBase {
  62
  63         @javax.annotation.Resource
  64         protected TitanDao titanDao;
  65
  66         @javax.annotation.Resource
  67         private NodeTypeOperation nodeTypeOperation;
  68
  69         @javax.annotation.Resource
  70         private TopologyTemplateOperation topologyTemplateOperation;
  71
  72         @javax.annotation.Resource
  73         private ToscaElementLifecycleOperation lifecycleOperation;
  74
  75         String categoryName = "category";
  76         String subcategory = "mycategory";
  77         String outputDirectory = "C:\\Output";
  78
  79         @Rule
  80         public TestName name = new TestName();
  81
  82         @BeforeClass
  83         public static void initLifecycleOperation() {
  84                 ModelTestBase.init();
  85         }
  86
  87         private GraphVertex ownerVertex;
  88         private GraphVertex modifierVertex;
  89         private GraphVertex vfVertex;
  90         private GraphVertex serviceVertex;
  91
  92         @Before
  93         public void setupBefore() {
  94                 clearGraph();
  95                 createUsers();
  96                 createResourceCategory();
  97                 createServiceCategory();
  98                 createRootNodeType();
  99                 createNodeType("firstVf");
 100                 createTopologyTemplate("firstService");
 101         }
 102
 103
 104         @Test
 105         public void lifecycleTest() {
 106                 Either<ToscaElement, StorageOperationStatus> res = lifecycleOperation
 107                                 .checkinToscaELement(LifecycleStateEnum.findState((String) vfVertex.getMetadataProperty(GraphPropertyEnum.STATE)),
 108                                                 vfVertex.getUniqueId(), modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 109                 StorageOperationStatus status;
 110
 111                 assertTrue(res.isLeft());
 112                 String id = res.left().value().getUniqueId();
 113
 114                 res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), modifierVertex.getUniqueId());
 115                 assertTrue(res.isLeft());
 116                 id = res.left().value().getUniqueId();
 117
 118                 PropertyDataDefinition prop55 = new PropertyDataDefinition();
 119                 prop55.setName("prop55");
 120                 prop55.setDefaultValue("def55");
 121
 122                 status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop55, JsonPresentationFields.NAME);
 123                 assertTrue(status == StorageOperationStatus.OK);
 124
 125                 CapabilityDataDefinition cap1 = new CapabilityDataDefinition();
 126                 cap1.setName("cap1");
 127                 cap1.setDescription("create");
 128                 cap1.setUniqueId(UniqueIdBuilder.buildCapabilityUid(id, "cap1"));
 129
 130                 status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.CAPABILITIES, VertexTypeEnum.CAPABILTIES, cap1, JsonPresentationFields.NAME);
 131                 assertTrue(status == StorageOperationStatus.OK);
 132
 133                 res = lifecycleOperation.checkinToscaELement(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId());
 134                 assertTrue(res.isLeft());
 135                 id = res.left().value().getUniqueId();
 136
 137                 res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId());
 138                 assertTrue(res.isLeft());
 139                 id = res.left().value().getUniqueId();
 140
 141                 prop55.setDefaultValue("AAAAAAAA");
 142                 status = nodeTypeOperation.updateToscaDataOfToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop55, JsonPresentationFields.NAME);
 143                 assertTrue(status == StorageOperationStatus.OK);
 144
 145                 cap1.setDescription("update");
 146
 147                 status = nodeTypeOperation.updateToscaDataOfToscaElement(id, EdgeLabelEnum.CAPABILITIES, VertexTypeEnum.CAPABILTIES, cap1, JsonPresentationFields.NAME);
 148                 assertTrue(status == StorageOperationStatus.OK);
 149
 150                 PropertyDataDefinition prop66 = new PropertyDataDefinition();
 151                 prop66.setName("prop66");
 152                 prop66.setDefaultValue("def66");
 153
 154                 status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop66, JsonPresentationFields.NAME);
 155                 assertTrue(status == StorageOperationStatus.OK);
 156
 157                 res = lifecycleOperation.requestCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 158                 assertTrue(res.isLeft());
 159                 id = res.left().value().getUniqueId();
 160
 161                 res = lifecycleOperation.startCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 162                 assertTrue(res.isLeft());
 163                 id = res.left().value().getUniqueId();
 164
 165                 res = lifecycleOperation.certifyToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 166                 assertTrue(res.isLeft());
 167                 id = res.left().value().getUniqueId();
 168
 169                 res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), modifierVertex.getUniqueId());
 170                 assertTrue(res.isLeft());
 171                 id = res.left().value().getUniqueId();
 172
 173                 PropertyDataDefinition prop77 = new PropertyDataDefinition();
 174                 prop77.setName("prop77");
 175                 prop77.setDefaultValue("def77");
 176
 177                 status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop77, JsonPresentationFields.NAME);
 178                 assertTrue(status == StorageOperationStatus.OK);
 179
 180                 res = lifecycleOperation.checkinToscaELement(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT, id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId());
 181                 assertTrue(res.isLeft());
 182                 id = res.left().value().getUniqueId();
 183
 184                 res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId());
 185                 assertTrue(res.isLeft());
 186                 id = res.left().value().getUniqueId();
 187
 188                 PropertyDataDefinition prop88 = new PropertyDataDefinition();
 189                 prop88.setName("prop88");
 190                 prop88.setDefaultValue("def88");
 191
 192                 status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop88, JsonPresentationFields.NAME);
 193                 assertTrue(status == StorageOperationStatus.OK);
 194
 195                 res = lifecycleOperation.requestCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 196                 assertTrue(res.isLeft());
 197                 id = res.left().value().getUniqueId();
 198
 199                 res = lifecycleOperation.startCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 200                 assertTrue(res.isLeft());
 201                 id = res.left().value().getUniqueId();
 202
 203                 res = lifecycleOperation.certifyToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 204                 assertTrue(res.isLeft());
 205                 id = res.left().value().getUniqueId();
 206
 207                 res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), ownerVertex.getUniqueId());
 208                 assertTrue(res.isLeft());
 209                 id = res.left().value().getUniqueId();
 210
 211                 PropertyDataDefinition prop99 = new PropertyDataDefinition();
 212                 prop99.setName("prop99");
 213                 prop99.setDefaultValue("def99");
 214
 215                 status = nodeTypeOperation.addToscaDataToToscaElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop99, JsonPresentationFields.NAME);
 216                 assertTrue(status == StorageOperationStatus.OK);
 217
 218                 res = lifecycleOperation.requestCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 219                 assertTrue(res.isLeft());
 220                 id = res.left().value().getUniqueId();
 221
 222                 res = lifecycleOperation.startCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 223                 assertTrue(res.isLeft());
 224                 id = res.left().value().getUniqueId();
 225
 226                 status = nodeTypeOperation.deleteToscaDataElement(id, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, "prop99", JsonPresentationFields.NAME);
 227                 assertTrue(status == StorageOperationStatus.OK);
 228
 229                 //cancel certification
 230                 res = lifecycleOperation.cancelOrFailCertification(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId(), LifecycleStateEnum.READY_FOR_CERTIFICATION);
 231                 assertTrue(res.isLeft());
 232                 id = res.left().value().getUniqueId();
 233
 234                 res = lifecycleOperation.startCertificationToscaElement(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 235                 assertTrue(res.isLeft());
 236                 id = res.left().value().getUniqueId();
 237
 238                 //fail certification
 239                 res = lifecycleOperation.cancelOrFailCertification(id, modifierVertex.getUniqueId(), ownerVertex.getUniqueId(), LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 240                 assertTrue(res.isLeft());
 241                 id = res.left().value().getUniqueId();
 242
 243                 //exportGraphMl(titanDao.getGraph().left().value());
 244
 245         }
 246
 247         @Test
 248         public void serviceConformanceLevelTest() {
 249                 Either<ToscaElement, StorageOperationStatus> res = lifecycleOperation
 250                                 .checkinToscaELement(LifecycleStateEnum.findState((String) serviceVertex.getMetadataProperty(GraphPropertyEnum.STATE)),
 251                                                 serviceVertex.getUniqueId(), modifierVertex.getUniqueId(), ownerVertex.getUniqueId());
 252
 253                 assertTrue(res.isLeft());
 254                 String id = res.left().value().getUniqueId();
 255
 256                 res = lifecycleOperation.checkoutToscaElement(id, ownerVertex.getUniqueId(), modifierVertex.getUniqueId());
 257                 assertTrue(res.isLeft());
 258
 259                 String conformanceLevel = res.left().value().getMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL).toString();
 260                 assertEquals(conformanceLevel, ModelTestBase.configurationManager.getConfiguration().getToscaConformanceLevel());
 261         }
 262
 263         private void createResourceCategory() {
 264
 265                 GraphVertex cat = new GraphVertex(VertexTypeEnum.RESOURCE_CATEGORY);
 266                 Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>();
 267                 String catId = UniqueIdBuilder.buildComponentCategoryUid(categoryName, VertexTypeEnum.RESOURCE_CATEGORY);
 268                 cat.setUniqueId(catId);
 269                 metadataProperties.put(GraphPropertyEnum.UNIQUE_ID,catId);
 270                 metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.RESOURCE_CATEGORY.getName());
 271                 metadataProperties.put(GraphPropertyEnum.NAME,categoryName);
 272                 metadataProperties.put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(categoryName));
 273                 cat.setMetadataProperties(metadataProperties);
 274                 cat.updateMetadataJsonWithCurrentMetadataProperties();
 275
 276                 GraphVertex subCat = new GraphVertex(VertexTypeEnum.RESOURCE_SUBCATEGORY);
 277                 metadataProperties = new HashMap<>();
 278                 String subCatId = UniqueIdBuilder.buildSubCategoryUid(cat.getUniqueId(), subcategory);
 279                 subCat.setUniqueId(subCatId);
 280                 metadataProperties.put(GraphPropertyEnum.UNIQUE_ID,subCatId);
 281                 metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.RESOURCE_SUBCATEGORY.getName());
 282                 metadataProperties.put(GraphPropertyEnum.NAME,subcategory);
 283                 subCat.setMetadataProperties(metadataProperties);
 284                 subCat.updateMetadataJsonWithCurrentMetadataProperties();
 285
 286                 Either<GraphVertex, TitanOperationStatus> catRes = titanDao.createVertex(cat);
 287
 288                 Either<GraphVertex, TitanOperationStatus> subCatRes = titanDao.createVertex(subCat);
 289
 290                 TitanOperationStatus status = titanDao.createEdge(catRes.left().value().getVertex(), subCatRes.left().value().getVertex(), EdgeLabelEnum.SUB_CATEGORY, new HashMap<>());
 291                 assertEquals(TitanOperationStatus.OK, status);
 292         }
 293
 294         private void createServiceCategory() {
 295
 296                 GraphVertex cat = new GraphVertex(VertexTypeEnum.SERVICE_CATEGORY);
 297                 Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>();
 298                 String catId = UniqueIdBuilder.buildComponentCategoryUid(categoryName, VertexTypeEnum.SERVICE_CATEGORY);
 299                 cat.setUniqueId(catId);
 300                 metadataProperties.put(GraphPropertyEnum.UNIQUE_ID,catId);
 301                 metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.SERVICE_CATEGORY.getName());
 302                 metadataProperties.put(GraphPropertyEnum.NAME,categoryName);
 303                 metadataProperties.put(GraphPropertyEnum.NORMALIZED_NAME, ValidationUtils.normalizeCategoryName4Uniqueness(categoryName));
 304                 cat.setMetadataProperties(metadataProperties);
 305                 cat.updateMetadataJsonWithCurrentMetadataProperties();
 306
 307                 Either<GraphVertex, TitanOperationStatus> catRes = titanDao.createVertex(cat);
 308
 309                 assertTrue(catRes.isLeft());
 310         }
 311
 312         private TopologyTemplate createTopologyTemplate(String name) {
 313
 314                 TopologyTemplate service = new TopologyTemplate();
 315                 String uniqueId = UniqueIdBuilder.buildResourceUniqueId();
 316                 service.setUniqueId(uniqueId);
 317                 service.setCreatorUserId((String) ownerVertex.getMetadataProperty(GraphPropertyEnum.USERID));
 318                 service.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), name);
 319                 service.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId);
 320                 service.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "0.1");
 321                 service.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(),ResourceTypeEnum.VF.name());
 322                 service.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(),ComponentTypeEnum.RESOURCE);
 323                 List<CategoryDefinition> categories = new ArrayList<>();
 324                 CategoryDefinition cat = new CategoryDefinition();
 325                 categories.add(cat);
 326                 cat.setName(categoryName);
 327                 service.setCategories(categories);
 328
 329                 service.setComponentType(ComponentTypeEnum.SERVICE);
 330                 Either<TopologyTemplate, StorageOperationStatus> createRes = topologyTemplateOperation.createTopologyTemplate(service);
 331                 assertTrue(createRes.isLeft());
 332
 333                 Either<GraphVertex, TitanOperationStatus> getNodeTyeRes= titanDao.getVertexById(createRes.left().value().getUniqueId());
 334                 assertTrue(getNodeTyeRes.isLeft());
 335
 336                 serviceVertex = getNodeTyeRes.left().value();
 337
 338                 return service;
 339         }
 340
 341         private <T extends ToscaDataDefinition> NodeType createNodeType(String nodeTypeName) {
 342
 343                 NodeType vf = new NodeType();
 344                 String uniqueId = UniqueIdBuilder.buildResourceUniqueId();
 345                 vf.setUniqueId(uniqueId);
 346                 vf.setCreatorUserId((String) ownerVertex.getMetadataProperty(GraphPropertyEnum.USERID));
 347                 vf.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), nodeTypeName);
 348                 vf.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId);
 349                 vf.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "0.1");
 350                 vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(),ResourceTypeEnum.VF.name());
 351                 vf.getMetadata().put(JsonPresentationFields.COMPONENT_TYPE.getPresentation(),ComponentTypeEnum.RESOURCE);
 352                 List<CategoryDefinition> categories = new ArrayList<>();
 353                 CategoryDefinition cat = new CategoryDefinition();
 354                 categories.add(cat);
 355                 cat.setName(categoryName);
 356                 List<SubCategoryDefinition> subCategories = new ArrayList<>();
 357                 SubCategoryDefinition subCat = new SubCategoryDefinition();
 358                 subCat.setName(subcategory);
 359                 subCategories.add(subCat);
 360                 cat.setSubcategories(subCategories);
 361                 vf.setCategories(categories);
 362
 363
 364                 List<String> derivedFrom = new ArrayList<>();
 365                 derivedFrom.add("root");
 366                 vf.setDerivedFrom(derivedFrom);
 367
 368 //               Map<String, PropertyDataDefinition> properties = new HashMap<>();
 369 //               PropertyDataDefinition prop1 = new PropertyDataDefinition();
 370 //               prop1.setName("prop1");
 371 //               prop1.setDefaultValue("def1");
 372 //
 373 //               properties.put("prop1", prop1);
 374 //
 375 //               PropertyDataDefinition prop2 = new PropertyDataDefinition();
 376 //               prop2.setName("prop2");
 377 //               prop2.setDefaultValue("def2");
 378 //               properties.put("prop2", prop2);
 379 //
 380 //               PropertyDataDefinition prop3 = new PropertyDataDefinition();
 381 //               prop3.setName("prop3");
 382 //               prop3.setDefaultValue("def3");
 383 //               properties.put("prop3", prop3);
 384 //
 385 //               vf.setProperties(properties);
 386                  vf.setComponentType(ComponentTypeEnum.RESOURCE);
 387                 Either<NodeType, StorageOperationStatus> createVFRes = nodeTypeOperation.createNodeType(vf);
 388                 assertTrue(createVFRes.isLeft());
 389
 390                 Either<GraphVertex, TitanOperationStatus> getNodeTyeRes= titanDao.getVertexById(createVFRes.left().value().getUniqueId());
 391                 assertTrue(getNodeTyeRes.isLeft());
 392
 393                 vfVertex = getNodeTyeRes.left().value();
 394
 395
 396
 397                  List<PropertyDataDefinition> addProperties = new ArrayList<>();
 398                  PropertyDataDefinition prop11 = new PropertyDataDefinition();
 399                  prop11.setName("prop11");
 400                  prop11.setDefaultValue("def11");
 401
 402                  addProperties.add(prop11);
 403
 404                  PropertyDataDefinition prop22 = new PropertyDataDefinition();
 405                  prop22.setName("prop22");
 406                  prop22.setDefaultValue("def22");
 407                  addProperties.add(prop22);
 408
 409                  StorageOperationStatus status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, addProperties, JsonPresentationFields.NAME);
 410                  assertTrue(status == StorageOperationStatus.OK);
 411
 412                  PropertyDataDefinition prop33 = new PropertyDataDefinition();
 413                  prop33.setName("prop33");
 414                  prop33.setDefaultValue("def33");
 415
 416                  status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex, EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop33, JsonPresentationFields.NAME);
 417                  assertTrue(status == StorageOperationStatus.OK);
 418
 419                  PropertyDataDefinition prop44 = new PropertyDataDefinition();
 420                  prop44.setName("prop44");
 421                  prop44.setDefaultValue("def44");
 422
 423                  status = nodeTypeOperation.addToscaDataToToscaElement(vfVertex.getUniqueId(), EdgeLabelEnum.PROPERTIES, VertexTypeEnum.PROPERTIES, prop44, JsonPresentationFields.NAME);
 424                  assertTrue(status == StorageOperationStatus.OK);
 425
 426
 427                  PropertyDataDefinition capProp = new PropertyDataDefinition();
 428                  capProp.setName( "capProp");
 429                  capProp.setDefaultValue( "capPropDef");
 430
 431                  MapDataDefinition dataToCreate = new MapPropertiesDataDefinition();
 432                  dataToCreate.put("capProp", capProp);
 433
 434                  Map<String, MapDataDefinition> capProps = new HashMap();
 435                  capProps.put("capName", dataToCreate);
 436
 437                  Either<GraphVertex, StorageOperationStatus> res = nodeTypeOperation.assosiateElementToData(vfVertex,  VertexTypeEnum.CAPABILITIES_PROPERTIES, EdgeLabelEnum.CAPABILITIES_PROPERTIES, capProps);
 438
 439                 // exportGraphMl(titanDao.getGraph().left().value());
 440
 441                  List<String> pathKeys = new ArrayList<>();
 442                  pathKeys.add("capName");
 443                  capProp.setDefaultValue( "BBBB");
 444                  status = nodeTypeOperation.updateToscaDataDeepElementOfToscaElement(vfVertex, EdgeLabelEnum.CAPABILITIES_PROPERTIES, VertexTypeEnum.CAPABILITIES_PROPERTIES,
 445                                  capProp, pathKeys, JsonPresentationFields.NAME);
 446                 return vf;
 447         }
 448
 449         private void createRootNodeType() {
 450
 451                 NodeType vf = new NodeType();
 452                 String uniqueId = UniqueIdBuilder.buildResourceUniqueId();
 453                 vf.setUniqueId(uniqueId);
 454                 vf.setComponentType(ComponentTypeEnum.RESOURCE);
 455                 vf.setCreatorUserId((String) ownerVertex.getMetadataProperty(GraphPropertyEnum.USERID));
 456                 vf.getMetadata().put(JsonPresentationFields.NAME.getPresentation(), "root");
 457                 vf.getMetadata().put(JsonPresentationFields.UNIQUE_ID.getPresentation(), uniqueId);
 458                 vf.getMetadata().put(JsonPresentationFields.VERSION.getPresentation(), "1.0");
 459                 vf.getMetadata().put(JsonPresentationFields.TYPE.getPresentation(),ResourceTypeEnum.VFC.name());
 460                 vf.getMetadata().put(JsonPresentationFields.LIFECYCLE_STATE.getPresentation(), LifecycleStateEnum.CERTIFIED.name());
 461                 vf.getMetadata().put(JsonPresentationFields.TOSCA_RESOURCE_NAME.getPresentation(), "root");
 462                 vf.getMetadata().put(JsonPresentationFields.HIGHEST_VERSION.getPresentation(), true);
 463
 464                 List<CategoryDefinition> categories = new ArrayList<>();
 465                 CategoryDefinition cat = new CategoryDefinition();
 466                 categories.add(cat);
 467                 cat.setName(categoryName);
 468                 List<SubCategoryDefinition> subCategories = new ArrayList<>();
 469                 SubCategoryDefinition subCat = new SubCategoryDefinition();
 470                 subCat.setName(subcategory);
 471                 subCategories.add(subCat);
 472                 cat.setSubcategories(subCategories);
 473                 vf.setCategories(categories);
 474
 475
 476                 List<String> derivedFrom = new ArrayList<>();
 477                 vf.setDerivedFrom(derivedFrom);
 478
 479                  Map<String, PropertyDataDefinition> properties = new HashMap<>();
 480                  PropertyDataDefinition prop1 = new PropertyDataDefinition();
 481                  prop1.setName("derived1");
 482                  prop1.setDefaultValue("deriveddef1");
 483
 484                  properties.put("derived1", prop1);
 485
 486                  PropertyDataDefinition prop2 = new PropertyDataDefinition();
 487                  prop2.setUniqueId("derived2");
 488                  prop2.setName("deriveddef2");
 489                  properties.put("derived2", prop2);
 490
 491                  PropertyDataDefinition prop3 = new PropertyDataDefinition();
 492                  prop3.setName("derived3");
 493                  prop3.setDefaultValue("deriveddef3");
 494                  properties.put("derived3", prop3);
 495
 496                  vf.setProperties(properties);
 497                  vf.setComponentType(ComponentTypeEnum.RESOURCE);
 498                 Either<NodeType, StorageOperationStatus> createVFRes = nodeTypeOperation.createNodeType(vf);
 499                 assertTrue(createVFRes.isLeft());
 500
 501                 Either<GraphVertex, TitanOperationStatus> getNodeTyeRes= titanDao.getVertexById(createVFRes.left().value().getUniqueId());
 502                 assertTrue(getNodeTyeRes.isLeft());
 503         }
 504
 505         private void createUsers() {
 506
 507                 GraphVertex ownerV = new GraphVertex(VertexTypeEnum.USER);
 508                 ownerV.setUniqueId("user1");
 509
 510                 Map<GraphPropertyEnum, Object> metadataProperties = new HashMap<>();
 511                 metadataProperties.put(GraphPropertyEnum.USERID, ownerV.getUniqueId());
 512                 metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.USER.getName());
 513                 metadataProperties.put(GraphPropertyEnum.NAME, "user1");
 514                 ownerV.setMetadataProperties(metadataProperties);
 515                 ownerV.updateMetadataJsonWithCurrentMetadataProperties();
 516                 ownerV.setJson(new HashMap<>());
 517                 Either<GraphVertex, TitanOperationStatus> createUserRes = titanDao.createVertex(ownerV);
 518                 assertTrue(createUserRes.isLeft());
 519
 520                 ownerVertex = createUserRes.left().value();
 521
 522                 GraphVertex modifierV = new GraphVertex(VertexTypeEnum.USER);
 523                 modifierV.setUniqueId("user2");
 524
 525                 metadataProperties = new HashMap<>();
 526                 metadataProperties.put(GraphPropertyEnum.USERID, modifierV.getUniqueId());
 527                 metadataProperties.put(GraphPropertyEnum.LABEL, VertexTypeEnum.USER.getName());
 528                 metadataProperties.put(GraphPropertyEnum.NAME, "user2");
 529                 modifierV.setMetadataProperties(metadataProperties);
 530                 modifierV.updateMetadataJsonWithCurrentMetadataProperties();
 531                 modifierV.setJson(new HashMap<>());
 532                 createUserRes = titanDao.createVertex(modifierV);
 533                 assertTrue(createUserRes.isLeft());
 534
 535                 modifierVertex = createUserRes.left().value();
 536
 537                 Either<GraphVertex, TitanOperationStatus> getOwnerRes = lifecycleOperation.findUser(ownerVertex.getUniqueId());
 538                 assertTrue(getOwnerRes.isLeft());
 539
 540         }
 541
 542         @After
 543         public void teardown() {
 544                 clearGraph();
 545         }
 546
 547         private void clearGraph() {
 548                 Either<TitanGraph, TitanOperationStatus> graphResult = titanDao.getGraph();
 549                 TitanGraph graph = graphResult.left().value();
 550
 551                 Iterable<TitanVertex> vertices = graph.query().vertices();
 552                 if (vertices != null) {
 553                         Iterator<TitanVertex> iterator = vertices.iterator();
 554                         while (iterator.hasNext()) {
 555                                 TitanVertex vertex = iterator.next();
 556                                 vertex.remove();
 557                         }
 558                 }
 559                 titanDao.commit();
 560         }
 561
 562         private String exportGraphMl(TitanGraph graph) {
 563                 String result = null;
 564                 String outputFile = outputDirectory + File.separator + "exportGraph." + System.currentTimeMillis() + ".graphml";
 565                 try {
 566                         try (final OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile))) {
 567                                 graph.io(IoCore.graphml()).writer().normalize(true).create().writeGraph(os, graph);
 568                         }
 569                         result = outputFile;
 570                         graph.tx().commit();
 571                 } catch (Exception e) {
 572                         graph.tx().rollback();
 573                         e.printStackTrace();
 574                 }
 575                 return result;
 576
 577         }
 578
 579 }