catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/ToscaElementLifecycleOperationTest.java

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