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.assertFalse;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertTrue;
  27
  28 import java.util.ArrayList;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Set;
  33 import java.util.regex.Pattern;
  34
  35 import org.apache.commons.lang3.tuple.ImmutablePair;
  36 import org.junit.Before;
  37 import org.junit.BeforeClass;
  38 import org.junit.Ignore;
  39 import org.junit.Test;
  40 import org.junit.runner.RunWith;
  41 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  42 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  43 import org.openecomp.sdc.be.dao.neo4j.GraphEdgePropertiesDictionary;
  44 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  45 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  46 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  47 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  48 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  49 import org.openecomp.sdc.be.model.ArtifactDefinition;
  50 import org.openecomp.sdc.be.model.CapabilityDefinition;
  51 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  52 import org.openecomp.sdc.be.model.ComponentInstance;
  53 import org.openecomp.sdc.be.model.HeatParameterDefinition;
  54 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  55 import org.openecomp.sdc.be.model.ModelTestBase;
  56 import org.openecomp.sdc.be.model.RelationshipImpl;
  57 import org.openecomp.sdc.be.model.RequirementAndRelationshipPair;
  58 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  59 import org.openecomp.sdc.be.model.RequirementDefinition;
  60 import org.openecomp.sdc.be.model.Resource;
  61 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  62 import org.openecomp.sdc.be.model.operations.impl.ArtifactOperation;
  63 import org.openecomp.sdc.be.model.operations.impl.CapabilityOperation;
  64 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
  65 import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
  66 import org.openecomp.sdc.be.model.operations.impl.HeatParametersOperation;
  67 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  68 import org.openecomp.sdc.be.model.operations.impl.RequirementOperation;
  69 import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
  70 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  71 import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil;
  72 import org.openecomp.sdc.be.model.operations.impl.util.PrintGraph;
  73 import org.openecomp.sdc.be.resources.data.ArtifactData;
  74 import org.openecomp.sdc.be.resources.data.HeatParameterData;
  75 import org.openecomp.sdc.be.resources.data.HeatParameterValueData;
  76 import org.openecomp.sdc.be.resources.data.RelationshipInstData;
  77 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  78 import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
  79 import org.openecomp.sdc.be.resources.data.UniqueIdData;
  80 import org.openecomp.sdc.be.resources.data.UserData;
  81 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  82 import org.slf4j.Logger;
  83 import org.slf4j.LoggerFactory;
  84 import org.springframework.test.context.ContextConfiguration;
  85 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  86
  87 import com.google.gson.Gson;
  88 import com.google.gson.GsonBuilder;
  89
  90 import fj.data.Either;
  91
  92 @RunWith(SpringJUnit4ClassRunner.class)
  93 @ContextConfiguration("classpath:application-context-test.xml")
  94 public class ResourceInstanceOperationTest extends ModelTestBase {
  95         private static Logger log = LoggerFactory.getLogger(ResourceInstanceOperationTest.class.getName());
  96         private Gson prettyGson = new GsonBuilder().setPrettyPrinting().create();
  97
  98         private static String USER_ID = "muUserId";
  99         private static String CATEGORY_NAME = "category/mycategory";
 100
 101         @javax.annotation.Resource(name = "titan-generic-dao")
 102         private TitanGenericDao titanDao;
 103
 104         @javax.annotation.Resource(name = "requirement-operation")
 105         private RequirementOperation requirementOperation;
 106
 107         @javax.annotation.Resource(name = "resource-operation")
 108         private ResourceOperation resourceOperation;
 109
 110         @javax.annotation.Resource(name = "property-operation")
 111         private PropertyOperation propertyOperation;
 112
 113         @javax.annotation.Resource(name = "capability-operation")
 114         private CapabilityOperation capabilityOperation;
 115
 116         @javax.annotation.Resource(name = "capability-type-operation")
 117         private CapabilityTypeOperation capabilityTypeOperation;
 118
 119         @javax.annotation.Resource(name = "component-instance-operation")
 120         private ComponentInstanceOperation resourceInstanceOperation;
 121
 122         @javax.annotation.Resource
 123         private HeatParametersOperation heatParameterOperation;
 124
 125         @javax.annotation.Resource
 126         private ArtifactOperation artifactOperation;
 127
 128         private String CAPABILITY_1 = "mycapability101";
 129         private String CAPABILITY_2 = "mycapability102";
 130
 131         private Integer TEST_CLASS_NUMBER = 1;
 132
 133         public final static Pattern COMPONENT_NAME_DELIMETER_PATTERN = Pattern.compile("[\\.\\-\\_]+");
 134
 135         public final static Pattern COMPONENT_INCTANCE_NAME_DELIMETER_PATTERN = Pattern.compile("[\\.\\-\\_]+");
 136
 137         @BeforeClass
 138         public static void setupBeforeClass() {
 139
 140                 // configurationManager = new ConfigurationManager(
 141                 // new ConfigurationSource() {
 142                 //
 143                 // @Override
 144                 // public <T> T getAndWatchConfiguration(Class<T> className,
 145                 // ConfigurationListener configurationListener) {
 146                 // // TODO Auto-generated method stub
 147                 // return null;
 148                 // }
 149                 //
 150                 // @Override
 151                 // public <T> void addWatchConfiguration(Class<T> className,
 152                 // ConfigurationListener configurationListener) {
 153                 // // TODO Auto-generated method stub
 154                 //
 155                 // }
 156                 // });
 157                 //
 158                 // Configuration configuration = new Configuration();
 159                 //
 160                 // ////inmemory
 161                 // boolean useInMemory = true;
 162                 // if (useInMemory) {
 163                 // configuration.setTitanInMemoryGraph(true);
 164                 // } else {
 165                 // configuration.setTitanInMemoryGraph(false);
 166                 // configuration.setTitanCfgFile("C:\\Git_work\\D2-SDnC\\catalog-be\\src\\main\\resources\\config\\titan.properties");
 167                 // }
 168                 //
 169                 //
 170                 //
 171                 // configurationManager.setConfiguration(configuration);
 172                 ModelTestBase.init();
 173         }
 174
 175         public void setOperations(TitanGenericDao titanDao, CapabilityTypeOperation capabilityTypeOperation, RequirementOperation requirementOperation, CapabilityOperation capabilityOperation, ResourceOperation resourceOperation,
 176                         PropertyOperation propertyOperation, ComponentInstanceOperation resourceInstanceOperation2) {
 177                 this.titanDao = titanDao;
 178                 this.capabilityTypeOperation = capabilityTypeOperation;
 179                 this.capabilityOperation = capabilityOperation;
 180                 this.requirementOperation = requirementOperation;
 181                 this.resourceOperation = resourceOperation;
 182                 this.propertyOperation = propertyOperation;
 183                 this.resourceInstanceOperation = resourceInstanceOperation2;
 184         }
 185
 186         @Test
 187         public void testDummy() {
 188
 189                 assertTrue(requirementOperation != null);
 190
 191         }
 192
 193         @Test
 194         public void testAddResourceInstanceInvalidServiceId() {
 195
 196                 try {
 197                         ComponentInstance instance = buildResourceInstance("tosca.nodes.Apache.2.0", "1", "tosca.nodes.Apache");
 198
 199                         Either<ComponentInstance, TitanOperationStatus> status = resourceInstanceOperation.addComponentInstanceToContainerComponent("service1", NodeTypeEnum.Service, "1", true, instance, NodeTypeEnum.Resource, false);
 200                         assertEquals("check failed status - service is not in graph", true, status.isRight());
 201                         assertEquals("check failed status value - service is not in graph", TitanOperationStatus.INVALID_ID, status.right().value());
 202                 } finally {
 203                         titanDao.rollback();
 204                 }
 205
 206         }
 207
 208         @Test
 209         public void testAddResourceInstanceValidServiceIdInvalidResourceId() {
 210                 try {
 211
 212                         ServiceMetadataData serviceData1 = createService("myservice1.1.0");
 213
 214                         ComponentInstance instance = buildResourceInstance("tosca.nodes.Apache.2.0", "1", "tosca.nodes.Apache");
 215
 216                         Either<ComponentInstance, TitanOperationStatus> status = resourceInstanceOperation.addComponentInstanceToContainerComponent((String) serviceData1.getUniqueId(), NodeTypeEnum.Service, "1", true, instance, NodeTypeEnum.Resource, false);
 217
 218                         assertEquals("check failed status - service is not in graph", true, status.isRight());
 219                         assertEquals("check failed status value - service is not in graph", TitanOperationStatus.INVALID_ID, status.right().value());
 220
 221                 } finally {
 222                         titanDao.rollback();
 223                 }
 224
 225         }
 226
 227         @Test
 228         public void testAddResourceInstanceValidServiceId() {
 229                 try {
 230                         String serviceName = "myservice1.1.0";
 231                         String resourceName = "tosca.nodes.Apache.2.0";
 232                         ServiceMetadataData serviceData1 = createService(serviceName);
 233                         ResourceMetadataData resourceData = createResource(resourceName);
 234
 235                         ComponentInstance instance = buildResourceInstance(resourceData.getMetadataDataDefinition().getUniqueId(), "1", "tosca.nodes.Apache");
 236
 237                         Either<ComponentInstance, TitanOperationStatus> status = resourceInstanceOperation.addComponentInstanceToContainerComponent((String) serviceData1.getUniqueId(), NodeTypeEnum.Service, "1", true, instance, NodeTypeEnum.Resource, false);
 238
 239                         assertEquals("check success status - service is not in graph", true, status.isLeft());
 240
 241                         ComponentInstance value = status.left().value();
 242                         assertEquals("check name exists", "tosca.nodes.Apache 1", value.getName());
 243
 244                         ServiceMetadataData serviceData2 = deleteService(serviceName);
 245                         ResourceMetadataData resourceData2 = deleteResource(resourceName);
 246
 247                 } finally {
 248                         titanDao.rollback();
 249                 }
 250         }
 251
 252         @Test
 253         public void testUpdateResourceInstance() {
 254                 try {
 255                         String serviceName = "myservice1.1.0";
 256                         String resourceName = "tosca.nodes.Apache.2.0";
 257                         ServiceMetadataData serviceData1 = createService(serviceName);
 258                         ResourceMetadataData resourceData = createResource(resourceName);
 259
 260                         ComponentInstance instance = buildResourceInstance(resourceData.getMetadataDataDefinition().getUniqueId(), "1", "tosca.nodes.Apache");
 261
 262                         Either<ComponentInstance, TitanOperationStatus> status = resourceInstanceOperation.addComponentInstanceToContainerComponent((String) serviceData1.getUniqueId(), NodeTypeEnum.Service, "1", true, instance, NodeTypeEnum.Resource, false);
 263
 264                         ComponentInstance resourceInstance = status.left().value();
 265                         Long creationTime = resourceInstance.getCreationTime();
 266                         String name = resourceInstance.getName();
 267                         assertEquals("check success status - service is not in graph", true, status.isLeft());
 268
 269                         ComponentInstance value = status.left().value();
 270                         assertEquals("check name exists", "tosca.nodes.Apache 1", value.getName());
 271
 272                         Either<ComponentInstance, StorageOperationStatus> u1Res = resourceInstanceOperation.updateResourceInstance((String) serviceData1.getUniqueId(), NodeTypeEnum.Service, resourceInstance.getUniqueId(), value, true);
 273                         assertTrue("check update succeed", u1Res.isLeft());
 274
 275                         Long lastModificationTimeNC = value.getModificationTime();
 276                         String desc = "AAAAA";
 277                         String posX = "15";
 278                         String posY = "12";
 279                         String updatedName = "Shlokshlik";
 280                         value.setDescription(desc);
 281                         value.setPosX(posX);
 282                         Either<ComponentInstance, StorageOperationStatus> u2Res = resourceInstanceOperation.updateResourceInstance((String) serviceData1.getUniqueId(), NodeTypeEnum.Service, resourceInstance.getUniqueId(), value, true);
 283                         assertTrue("check update succeed", u2Res.isLeft());
 284                         assertEquals("check resource instance updated", desc, u2Res.left().value().getDescription());
 285                         assertEquals("check resource instance updated", posX, u2Res.left().value().getPosX());
 286                         assertEquals("check resource instance updated", resourceInstance.getPosY(), u2Res.left().value().getPosY());
 287                         assertEquals("check modification time was not updated since it was supplied", u2Res.left().value().getModificationTime(), lastModificationTimeNC);
 288
 289                         Long lastModificationTime = value.getModificationTime();
 290                         value.setPosY(posY);
 291                         value.setModificationTime(null);
 292                         value.setName(updatedName);
 293                         Either<ComponentInstance, StorageOperationStatus> u3Res = resourceInstanceOperation.updateResourceInstance((String) serviceData1.getUniqueId(), NodeTypeEnum.Service, resourceInstance.getUniqueId(), value, true);
 294                         assertTrue("check update succeed", u3Res.isLeft());
 295                         assertEquals("check resource instance updated", desc, u3Res.left().value().getDescription());
 296                         assertEquals("check resource pos x updated", posX, u3Res.left().value().getPosX());
 297                         assertEquals("check resource pos y updated", posY, u3Res.left().value().getPosY());
 298                         assertTrue("check modification time was updated", u3Res.left().value().getModificationTime() >= lastModificationTime);
 299                         assertEquals("check creation time was not updated", creationTime, u3Res.left().value().getCreationTime());
 300                         assertEquals("check name was  updated", updatedName, u3Res.left().value().getName());
 301
 302                         ServiceMetadataData serviceData2 = deleteService(serviceName);
 303                         ResourceMetadataData resourceData2 = deleteResource(resourceName);
 304
 305                 } finally {
 306                         titanDao.rollback();
 307                 }
 308         }
 309
 310         @Test
 311         public void testRemoveResourceInstance() {
 312                 try {
 313                         String serviceName = "myservice1.1.0";
 314                         String resourceName = "tosca.nodes.Apache.2.0";
 315                         ServiceMetadataData serviceData1 = createService(serviceName);
 316                         ResourceMetadataData resourceData = createResource(resourceName);
 317
 318                         ComponentInstance instance = buildResourceInstance(resourceData.getMetadataDataDefinition().getUniqueId(), "1", "tosca.nodes.Apache");
 319
 320                         Either<ComponentInstance, TitanOperationStatus> status = resourceInstanceOperation.addComponentInstanceToContainerComponent((String) serviceData1.getUniqueId(), NodeTypeEnum.Service, "1", true, instance, NodeTypeEnum.Resource, false);
 321
 322                         assertEquals("check success status - service is not in graph", true, status.isLeft());
 323
 324                         ComponentInstance value = status.left().value();
 325                         assertEquals("check name exists", "tosca.nodes.Apache 1", value.getName());
 326
 327                         Either<ComponentInstance, TitanOperationStatus> status1 = resourceInstanceOperation.removeComponentInstanceFromComponent(NodeTypeEnum.Service, serviceName, value.getUniqueId());
 328
 329                         assertTrue("check resource service was deleted.", status1.isLeft());
 330                         assertEquals("check resource instance returned.", "tosca.nodes.Apache 1", status1.left().value().getName());
 331
 332                         ServiceMetadataData serviceData2 = deleteService(serviceName);
 333                         ResourceMetadataData resourceData2 = deleteResource(resourceName);
 334
 335                 } finally {
 336                         titanDao.rollback();
 337                 }
 338         }
 339
 340         @Test
 341         public void testRemoveResourceInstanceNotFound() {
 342                 try {
 343                         String serviceName = "myservice1.1.0";
 344                         ServiceMetadataData serviceData1 = createService(serviceName);
 345
 346                         Either<ComponentInstance, TitanOperationStatus> status1 = resourceInstanceOperation.removeComponentInstanceFromComponent(NodeTypeEnum.Service, serviceName, "stam");
 347
 348                         assertTrue("check resource service was not deleted.", status1.isRight());
 349                         assertEquals("check NOT_FOUND returned.", TitanOperationStatus.NOT_FOUND, status1.right().value());
 350
 351                         ServiceMetadataData serviceData2 = deleteService(serviceName);
 352
 353                 } finally {
 354                         titanDao.rollback();
 355                 }
 356         }
 357
 358         public ServiceMetadataData createService(String serviceName) {
 359
 360                 ServiceMetadataData serviceData1 = new ServiceMetadataData();
 361                 serviceData1.getMetadataDataDefinition().setUniqueId(serviceName);
 362                 Either<ServiceMetadataData, TitanOperationStatus> createNode = titanDao.createNode(serviceData1, ServiceMetadataData.class);
 363
 364                 assertTrue("check service created", createNode.isLeft());
 365                 return createNode.left().value();
 366         }
 367
 368         public ServiceMetadataData deleteService(String serviceName) {
 369
 370                 ServiceMetadataData serviceData1 = new ServiceMetadataData();
 371                 serviceData1.getMetadataDataDefinition().setUniqueId(serviceName);
 372                 Either<ServiceMetadataData, TitanOperationStatus> createNode = titanDao.deleteNode(serviceData1, ServiceMetadataData.class);
 373                 assertTrue("check service deleted", createNode.isLeft());
 374                 return createNode.left().value();
 375         }
 376
 377         public ResourceMetadataData createResource(String resourceName) {
 378
 379                 ResourceMetadataData serviceData1 = new ResourceMetadataData();
 380                 serviceData1.getMetadataDataDefinition().setUniqueId(resourceName);
 381                 Either<ResourceMetadataData, TitanOperationStatus> createNode = titanDao.createNode(serviceData1, ResourceMetadataData.class);
 382
 383                 assertTrue("check service created", createNode.isLeft());
 384                 return createNode.left().value();
 385         }
 386
 387         public ResourceMetadataData deleteResource(String resourceName) {
 388
 389                 ResourceMetadataData serviceData1 = new ResourceMetadataData();
 390                 serviceData1.getMetadataDataDefinition().setUniqueId(resourceName);
 391                 Either<ResourceMetadataData, TitanOperationStatus> createNode = titanDao.deleteNode(serviceData1, ResourceMetadataData.class);
 392
 393                 assertTrue("check service created", createNode.isLeft());
 394                 return createNode.left().value();
 395         }
 396
 397         @Test
 398         public void testAddResourceInstanceJson() {
 399                 addResourceInstanceJson();
 400         }
 401
 402         public ComponentInstance addResourceInstanceJson() {
 403
 404                 ComponentInstance resourceInstance = buildResourceInstance("tosca.nodes.Apache.2.0", "1", "tosca.nodes.Apache");
 405
 406                 String json = prettyGson.toJson(resourceInstance);
 407                 log.debug(json);
 408
 409                 return resourceInstance;
 410
 411         }
 412
 413         private ComponentInstance buildResourceInstance(String respurceUid, String instanceNumber, String name) {
 414                 ComponentInstance resourceInstance = new ComponentInstance();
 415                 // resourceInstance
 416                 // .setUniqueId("<SN>.tosca.nodes.Apache.2.0." + instanceNumber);
 417                 resourceInstance.setName(name);
 418                 resourceInstance.setDescription("desc1");
 419                 resourceInstance.setPosX("20");
 420                 resourceInstance.setPosY("40");
 421                 resourceInstance.setComponentUid(respurceUid);
 422                 resourceInstance.setCreationTime(System.currentTimeMillis());
 423                 resourceInstance.setModificationTime(System.currentTimeMillis());
 424                 resourceInstance.setNormalizedName(normaliseComponentInstanceName(name));
 425
 426                 // Map<String, RequirementInstance> requirements = new HashMap<String,
 427                 // RequirementInstance>();
 428                 //
 429                 // RequirementInstance requirementInstance1 = new RequirementInstance();
 430                 // requirementInstance1.setNode("NA");
 431                 // RelationshipImpl relationshipImpl = new RelationshipImpl();
 432                 // relationshipImpl.setType("tosca.relationships.HostedOn");
 433                 // requirementInstance1.setRelationship(relationshipImpl);
 434                 //
 435                 // requirements.put("host", requirementInstance1);
 436                 //
 437                 // RequirementInstance requirementInstance2 = new RequirementInstance();
 438                 // requirementInstance2.setNode("NA");
 439                 // RelationshipImpl relationshipImpl2 = new RelationshipImpl();
 440                 // relationshipImpl2.setType("tosca.relationships.LinkTo");
 441                 // requirementInstance2.setRelationship(relationshipImpl2);
 442                 //
 443                 // requirements.put("link", requirementInstance2);
 444                 //
 445                 // resourceInstance.setRequirements(requirements);
 446                 return resourceInstance;
 447         }
 448
 449         @Test
 450         @Ignore
 451         public void testConenctResourceInstancesJson() {
 452                 RequirementCapabilityRelDef addRelationship = addRelationship("apache_1", "compute_100");
 453                 String json = prettyGson.toJson(addRelationship);
 454                 log.debug(json);
 455
 456                 RequirementCapabilityRelDef capabilityRelDef = prettyGson.fromJson(json, RequirementCapabilityRelDef.class);
 457                 log.debug("{}", capabilityRelDef);
 458
 459         }
 460
 461         public RequirementCapabilityRelDef addRelationship(String from, String to) {
 462                 RequirementCapabilityRelDef requirementCapabilityRelDef = new RequirementCapabilityRelDef();
 463                 requirementCapabilityRelDef.setFromNode(from);
 464                 requirementCapabilityRelDef.setToNode(to);
 465                 List<RequirementAndRelationshipPair> relationships = new ArrayList<RequirementAndRelationshipPair>();
 466
 467                 String req = "host";
 468                 RelationshipImpl relationshipImpl = new RelationshipImpl();
 469                 relationshipImpl.setType("tosca.nodes.HostedOn");
 470                 RequirementAndRelationshipPair rels = new RequirementAndRelationshipPair(req, relationshipImpl);
 471                 relationships.add(rels);
 472
 473                 requirementCapabilityRelDef.setRelationships(relationships);
 474
 475                 return requirementCapabilityRelDef;
 476         }
 477
 478         @Before
 479         public void createUserAndCategory() {
 480                 deleteAndCreateCategory(CATEGORY_NAME);
 481                 deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID);
 482         }
 483
 484         private UserData deleteAndCreateUser(String userId, String firstName, String lastName) {
 485                 UserData userData = new UserData();
 486                 userData.setUserId(userId);
 487                 userData.setFirstName(firstName);
 488                 userData.setLastName(lastName);
 489
 490                 titanDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class);
 491                 titanDao.createNode(userData, UserData.class);
 492                 titanDao.commit();
 493
 494                 return userData;
 495         }
 496
 497         private void deleteAndCreateCategory(String category) {
 498                 String[] names = category.split("/");
 499                 OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanDao);
 500                 OperationTestsUtil.deleteAndCreateServiceCategory(category, titanDao);
 501
 502                 /*
 503                  * CategoryData categoryData = new CategoryData(); categoryData.setName(category);
 504                  *
 505                  * titanDao.deleteNode(categoryData, CategoryData.class); Either<CategoryData, TitanOperationStatus> createNode = titanDao .createNode(categoryData, CategoryData.class); System.out.println("after creating caetgory " + createNode);
 506                  */
 507         }
 508
 509         @Test
 510         @Ignore
 511         public void testConnectResourceInstances() {
 512
 513                 PrintGraph printGraph1 = new PrintGraph();
 514                 int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
 515                 try {
 516
 517                         String capabilityTypeName = CAPABILITY_2;
 518                         String reqName = "host";
 519                         String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
 520                         String rootName = "Root2" + TEST_CLASS_NUMBER;
 521                         String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
 522                         String computeNodeName = reqNodeName;
 523                         String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
 524                         String reqRelationship = "myrelationship";
 525
 526                         // Create Capability type
 527                         CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
 528                         capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
 529                         CapabilityTypeDefinition createCapabilityDef = capabilityTypeOperationTest.createCapability(capabilityTypeName);
 530                         ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
 531                         resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
 532
 533                         // create root resource
 534                         Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null, true, true);
 535                         ResourceMetadataData resourceData = new ResourceMetadataData();
 536                         resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
 537                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
 538                         Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
 539                         assertTrue(updateNode.isLeft());
 540
 541                         Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation.getResource(rootResource.getUniqueId(), true);
 542
 543                         String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
 544                         log.debug(rootResourceJson);
 545
 546                         // create software component
 547                         Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName, "1.0", rootResource.getName(), true, true);
 548
 549                         resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
 550                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
 551                         updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
 552                         assertTrue(updateNode.isLeft());
 553
 554                         // create compute component
 555                         Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName, "1.0", rootResource.getName(), true, true);
 556
 557                         // rollbackAndPrint();
 558
 559                         // Add capabilities to Compute Resource
 560                         CapabilityDefinition addCapability = addCapabilityToResource(capabilityTypeName, "host", computeComponent);
 561
 562                         // create requirement definition
 563
 564                         Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(capabilityTypeName, reqName, reqNodeName, reqRelationship, softwareComponent);
 565
 566                         String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
 567
 568                         // create my resource derived from software component
 569                         Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource", myResourceVersion, softwareComponent.getName(), true, true);
 570
 571                         String serviceName = "myservice.1.0";
 572                         List<ComponentInstance> resInstances = buildServiceAndConnectBetweenResourceInstances(serviceName, resource, computeComponent, "host", false, addCapability.getUniqueId(), addRequirementToResource.left().value().getUniqueId());
 573
 574                         PrintGraph printGraph = new PrintGraph();
 575                         String webGraph = printGraph.buildGraphForWebgraphWiz(titanDao.getGraph().left().value());
 576                         log.debug(webGraph);
 577
 578                         Either<Resource, StorageOperationStatus> resourceFull = resourceOperation.getResource(resource.getUniqueId());
 579                         assertTrue(resourceFull.isLeft());
 580                         List<RequirementCapabilityRelDef> componentInstancesRelations = resourceFull.left().value().getComponentInstancesRelations();
 581
 582                         RequirementCapabilityRelDef capabilityRelDef = componentInstancesRelations.get(0);
 583                         capabilityRelDef.getRelationships().get(0).setRequirement("host");
 584
 585                         // disconnectResourcesInService(serviceName, resInstances.get(0),
 586                         // "host");
 587                         disconnectResourcesInService(serviceName, capabilityRelDef);
 588
 589                 } finally {
 590                         rollbackAndPrint(false);
 591                         compareGraphSize(numberOfVertices);
 592                 }
 593
 594         }
 595
 596         @Test
 597         @Ignore
 598         public void testConnectResourceInstances1Requirement2Capabilities() {
 599
 600                 PrintGraph printGraph1 = new PrintGraph();
 601                 int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
 602
 603                 try {
 604
 605                         String capabilityTypeName1 = CAPABILITY_1;
 606                         String capabilityTypeName2 = CAPABILITY_2;
 607                         String reqName1 = "host1";
 608                         String reqName2 = "host2";
 609                         String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
 610                         String rootName = "Root2" + TEST_CLASS_NUMBER;
 611                         String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
 612                         String computeNodeName = reqNodeName;
 613                         String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
 614                         String reqRelationship = "myrelationship";
 615
 616                         // Create Capability type
 617                         CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
 618                         capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
 619                         CapabilityTypeDefinition createCapabilityDef1 = capabilityTypeOperationTest.createCapability(capabilityTypeName1);
 620                         CapabilityTypeDefinition createCapabilityDef2 = capabilityTypeOperationTest.createCapability(capabilityTypeName2);
 621
 622                         ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
 623                         resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
 624
 625                         // create root resource
 626                         Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null, true, true);
 627
 628                         ResourceMetadataData resourceData = new ResourceMetadataData();
 629                         resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
 630                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
 631                         Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
 632                         assertTrue(updateNode.isLeft());
 633
 634                         Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation.getResource(rootResource.getUniqueId(), true);
 635
 636                         String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
 637                         log.debug(rootResourceJson);
 638
 639                         // create software component
 640                         Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName, "1.0", rootResource.getName(), true, true);
 641
 642                         resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
 643                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
 644                         updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
 645                         assertTrue(updateNode.isLeft());
 646
 647                         // create compute component
 648                         Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName, "1.0", rootResource.getName(), true, true);
 649
 650                         // Add capabilities to Compute Resource
 651                         CapabilityDefinition capabilty1 = addCapabilityToResource(capabilityTypeName1, reqName1, computeComponent);
 652                         CapabilityDefinition capabilty2 = addCapabilityToResource(capabilityTypeName2, reqName2, computeComponent);
 653
 654                         // rollbackAndPrint();
 655
 656                         // create requirement definition
 657
 658                         Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(capabilityTypeName1, reqName1, reqNodeName, reqRelationship, softwareComponent);
 659
 660                         String requirementId = addRequirementToResource.left().value().getUniqueId();
 661                         String parentReqUniqId = requirementId;
 662
 663                         // create my resource derived from software component
 664                         Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource", myResourceVersion, softwareComponent.getName(), true, true);
 665
 666                         String serviceName = "myservice.1.0";
 667                         List<ComponentInstance> resInstances = buildServiceAndConnectBetweenResourceInstances(serviceName, resource, computeComponent, reqName1, false, capabilty1.getUniqueId(), requirementId);
 668
 669                         PrintGraph printGraph = new PrintGraph();
 670                         String webGraph = printGraph.buildGraphForWebgraphWiz(titanDao.getGraph().left().value());
 671                         log.debug(webGraph);
 672
 673                         RequirementAndRelationshipPair relationPair = new RequirementAndRelationshipPair();
 674                         relationPair.setRequirement(reqName2);
 675
 676                         relationPair.setCapabilityUid(capabilty1.getUniqueId());
 677                         relationPair.setRequirementUid(requirementId);
 678
 679                         Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService1 = resourceInstanceOperation.connectResourcesInService(serviceName, NodeTypeEnum.Service, resInstances.get(0).getUniqueId(), resInstances.get(1).getUniqueId(),
 680                                         relationPair);
 681                         assertEquals("check cannot associate resource instances", TitanOperationStatus.ILLEGAL_ARGUMENT, connectResourcesInService1.right().value());
 682                         relationPair.setRequirement(reqName1);
 683                         Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService2 = resourceInstanceOperation.connectResourcesInService(serviceName, NodeTypeEnum.Service, resInstances.get(0).getUniqueId(), resInstances.get(1).getUniqueId(),
 684                                         relationPair);
 685                         assertEquals("check cannot associate resource instances", TitanOperationStatus.TITAN_SCHEMA_VIOLATION, connectResourcesInService2.right().value());
 686
 687                         relationPair.setRequirement(reqName1);
 688
 689                         RequirementCapabilityRelDef capabilityRelDef = new RequirementCapabilityRelDef();
 690                         capabilityRelDef.setFromNode(resInstances.get(0).getUniqueId());
 691                         capabilityRelDef.setToNode(resInstances.get(1).getUniqueId());
 692                         List<RequirementAndRelationshipPair> list = new ArrayList<>();
 693                         list.add(relationPair);
 694
 695                         disconnectResourcesInService(serviceName, capabilityRelDef);
 696
 697                 } finally {
 698                         rollbackAndPrint();
 699                         compareGraphSize(numberOfVertices);
 700                 }
 701
 702         }
 703
 704         private void rollbackAndPrint() {
 705                 rollbackAndPrint(false);
 706         }
 707
 708         private void rollbackAndPrint(boolean print) {
 709                 TitanOperationStatus rollback = titanDao.rollback();
 710                 if (print) {
 711                         log.debug("rollback status={}", rollback);
 712                         PrintGraph printGraph = new PrintGraph();
 713                         printGraph.printGraphVertices(titanDao.getGraph().left().value());
 714                 }
 715         }
 716
 717         @Test
 718         @Ignore
 719         public void testConnectResourceInstances2Requirement2Capabilities() {
 720
 721                 PrintGraph printGraph1 = new PrintGraph();
 722                 int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
 723
 724                 try {
 725
 726                         String capabilityTypeName1 = CAPABILITY_1;
 727                         String capabilityTypeName2 = CAPABILITY_2;
 728                         String reqName1 = "host1";
 729                         String reqName2 = "host2";
 730                         String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
 731                         String rootName = "Root2" + TEST_CLASS_NUMBER;
 732                         String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
 733                         String computeNodeName = reqNodeName;
 734                         String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
 735                         String reqRelationship = "myrelationship";
 736
 737                         // Create Capability type
 738                         CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
 739                         capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
 740                         CapabilityTypeDefinition createCapabilityDef1 = capabilityTypeOperationTest.createCapability(capabilityTypeName1);
 741                         CapabilityTypeDefinition createCapabilityDef2 = capabilityTypeOperationTest.createCapability(capabilityTypeName2);
 742
 743                         ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
 744                         resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
 745
 746                         // create root resource
 747                         Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null, true, true);
 748                         ResourceMetadataData resourceData = new ResourceMetadataData();
 749                         resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
 750                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
 751                         Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
 752                         assertTrue(updateNode.isLeft());
 753
 754                         Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation.getResource(rootResource.getUniqueId(), true);
 755
 756                         String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
 757                         log.debug(rootResourceJson);
 758
 759                         // rollbackAndPrint();
 760                         // OKKKKKKK
 761
 762                         // create software component
 763                         Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName, "1.0", rootResource.getName(), true, true);
 764
 765                         resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
 766                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
 767                         updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
 768                         assertTrue(updateNode.isLeft());
 769
 770                         // create compute component
 771                         Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName, "1.0", rootResource.getName(), true, true);
 772
 773                         // rollbackAndPrint();
 774                         // OKKKKKKKKKK
 775
 776                         // Add capabilities to Compute Resource
 777                         CapabilityDefinition capabilty1 = addCapabilityToResource(capabilityTypeName1, reqName1, computeComponent);
 778                         CapabilityDefinition capabilty2 = addCapabilityToResource(capabilityTypeName2, reqName2, computeComponent);
 779
 780                         // rollbackAndPrint();
 781
 782                         // create requirement definition
 783
 784                         Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource1 = addRequirementToResource(capabilityTypeName1, reqName1, reqNodeName, reqRelationship, softwareComponent);
 785
 786                         Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource2 = addRequirementToResource(capabilityTypeName2, reqName2, reqNodeName, reqRelationship, softwareComponent);
 787
 788                         // create my resource derived from software component
 789                         String MY_RESOURCE = "my-resource";
 790                         Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, MY_RESOURCE, myResourceVersion, softwareComponent.getName(), true, true);
 791
 792                         String serviceName = "myservice.1.0";
 793                         String requirementId1 = addRequirementToResource1.left().value().getUniqueId();
 794                         String requirementId2 = addRequirementToResource2.left().value().getUniqueId();
 795                         List<ComponentInstance> resInstances = buildServiceAndConnectBetweenResourceInstances(serviceName, resource, computeComponent, reqName1, false, capabilty1.getUniqueId(), requirementId1);
 796
 797                         RequirementAndRelationshipPair relationPair = new RequirementAndRelationshipPair();
 798                         relationPair.setRequirement(reqName2);
 799                         relationPair.setCapabilityUid(capabilty2.getUniqueId());
 800                         relationPair.setRequirementUid(requirementId2);
 801                         relationPair.setCapabilityOwnerId(resInstances.get(1).getUniqueId());
 802                         relationPair.setRequirementOwnerId(resInstances.get(0).getUniqueId());
 803                         Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService1 = resourceInstanceOperation.connectResourcesInService(serviceName, NodeTypeEnum.Service, resInstances.get(0).getUniqueId(), resInstances.get(1).getUniqueId(),
 804                                         relationPair);
 805                         assertTrue("check associate resource instances succeed " + reqName2, connectResourcesInService1.isLeft());
 806
 807                         // rollbackAndPrint();
 808
 809                         PrintGraph printGraph = new PrintGraph();
 810                         String webGraph = printGraph.buildGraphForWebgraphWiz(titanDao.getGraph().left().value());
 811                         log.debug(webGraph);
 812
 813                         RequirementCapabilityRelDef reqCapDef = new RequirementCapabilityRelDef();
 814                         reqCapDef.setFromNode(resInstances.get(0).getUniqueId());
 815                         reqCapDef.setToNode(resInstances.get(1).getUniqueId());
 816
 817                         relationPair.setRequirement(reqName1);
 818                         relationPair.setCapabilityUid(capabilty1.getUniqueId());
 819                         relationPair.setRequirementUid(requirementId1);
 820                         RelationshipImpl relationship = new RelationshipImpl();
 821                         relationship.setType(reqName1);
 822                         relationPair.setRelationships(relationship);
 823
 824                         List<RequirementAndRelationshipPair> list = new ArrayList<>();
 825                         list.add(relationPair);
 826                         reqCapDef.setRelationships(list);
 827
 828                         disconnectResourcesInService(serviceName, reqCapDef);
 829
 830                         reqCapDef.getRelationships().clear();
 831
 832                         RequirementAndRelationshipPair relationPair1 = new RequirementAndRelationshipPair();
 833                         relationPair1.setRequirement(reqName2);
 834                         relationPair1.setCapabilityUid(capabilty2.getUniqueId());
 835                         relationPair1.setRequirementUid(requirementId2);
 836                         relationPair1.setCapabilityOwnerId(resInstances.get(1).getUniqueId());
 837                         relationPair1.setRequirementOwnerId(resInstances.get(0).getUniqueId());
 838                         relationship.setType(reqName2);
 839                         relationPair1.setRelationships(relationship);
 840                         reqCapDef.getRelationships().add(relationPair1);
 841
 842                         disconnectResourcesInService(serviceName, reqCapDef);
 843
 844                         RequirementCapabilityRelDef relation = new RequirementCapabilityRelDef();
 845                         String fromResUid = resInstances.get(0).getUniqueId();
 846                         String toResUid = resInstances.get(1).getUniqueId();
 847                         relation.setFromNode(fromResUid);
 848                         relation.setToNode(toResUid);
 849                         List<RequirementAndRelationshipPair> relationships = new ArrayList<RequirementAndRelationshipPair>();
 850                         RequirementAndRelationshipPair immutablePair1 = new RequirementAndRelationshipPair(reqName1, null);
 851                         RequirementAndRelationshipPair immutablePair2 = new RequirementAndRelationshipPair(reqName2, null);
 852                         immutablePair1.setCapabilityUid(capabilty1.getUniqueId());
 853                         immutablePair1.setRequirementUid(addRequirementToResource1.left().value().getUniqueId());
 854                         immutablePair1.setRequirementOwnerId(resInstances.get(0).getUniqueId());
 855                         immutablePair1.setCapabilityOwnerId(resInstances.get(1).getUniqueId());
 856
 857                         immutablePair2.setCapabilityUid(capabilty2.getUniqueId());
 858                         immutablePair2.setRequirementUid(addRequirementToResource2.left().value().getUniqueId());
 859                         immutablePair2.setRequirementOwnerId(resInstances.get(0).getUniqueId());
 860                         immutablePair2.setCapabilityOwnerId(resInstances.get(1).getUniqueId());
 861
 862                         relationships.add(immutablePair1);
 863                         relationships.add(immutablePair2);
 864                         relation.setRelationships(relationships);
 865
 866                         Either<RequirementCapabilityRelDef, StorageOperationStatus> associateResourceInstances = resourceInstanceOperation.associateResourceInstances(serviceName, NodeTypeEnum.Service, relation, true, false);
 867                         assertTrue("check return code after associating 2 requirements in one request", associateResourceInstances.isLeft());
 868                         RequirementCapabilityRelDef capabilityRelDef = associateResourceInstances.left().value();
 869                         String fromNode = capabilityRelDef.getFromNode();
 870                         assertEquals("check from node", resInstances.get(0).getUniqueId(), fromNode);
 871                         String toNode = capabilityRelDef.getToNode();
 872                         assertEquals("check to node", resInstances.get(1).getUniqueId(), toNode);
 873                         List<RequirementAndRelationshipPair> relationships2 = capabilityRelDef.getRelationships();
 874                         assertEquals("check number of relations", 2, relationships2.size());
 875
 876                         for (RequirementAndRelationshipPair pair : relationships2) {
 877                                 String key = pair.getRequirement();
 878                                 RelationshipImpl relationshipImpl = pair.getRelationship();
 879                                 if (key.equals(reqName1)) {
 880                                         String type = relationshipImpl.getType();
 881                                         assertEquals("Check relationship type name", reqRelationship, type);
 882                                 } else if (key.equals(reqName2)) {
 883                                         String type = relationshipImpl.getType();
 884                                         assertEquals("Check relationship type name", reqRelationship, type);
 885                                 } else {
 886                                         assertTrue("requirement " + key + " was not found in the original request", false);
 887                                 }
 888                         }
 889
 890                         verifyGetAllResourceInstanceFromService(reqName1, reqName2, serviceName, fromResUid, toResUid);
 891
 892                         List<ResourceMetadataData> resourcesPathList = new ArrayList<ResourceMetadataData>();
 893                         TitanOperationStatus findResourcesPathRecursively = resourceOperation.findResourcesPathRecursively(resource.getUniqueId(), resourcesPathList);
 894                         assertEquals("check returned status", TitanOperationStatus.OK, findResourcesPathRecursively);
 895                         assertEquals("check list size", 3, resourcesPathList.size());
 896
 897                         TitanOperationStatus validateTheTargetResourceInstance = resourceInstanceOperation.validateTheTargetResourceInstance(MY_RESOURCE, resource.getUniqueId());
 898                         assertEquals("check resource name in the path", TitanOperationStatus.OK, validateTheTargetResourceInstance);
 899                         validateTheTargetResourceInstance = resourceInstanceOperation.validateTheTargetResourceInstance(softwareCompName, resource.getUniqueId());
 900                         assertEquals("check resource name in the path", TitanOperationStatus.OK, validateTheTargetResourceInstance);
 901
 902                         validateTheTargetResourceInstance = resourceInstanceOperation.validateTheTargetResourceInstance(softwareCompName + "STAM", resource.getUniqueId());
 903                         assertEquals("check resource name not in the path", TitanOperationStatus.MATCH_NOT_FOUND, validateTheTargetResourceInstance);
 904
 905                         Either<ComponentInstance, StorageOperationStatus> deleteResourceInstance = resourceInstanceOperation.deleteComponentInstance(NodeTypeEnum.Service, serviceName, toResUid, true);
 906                         assertTrue("check resource instance was deleted.", deleteResourceInstance.isLeft());
 907
 908                 } finally {
 909                         rollbackAndPrint(false);
 910                         compareGraphSize(numberOfVertices);
 911                 }
 912
 913         }
 914
 915         private void verifyGetAllResourceInstanceFromService(String reqName1, String reqName2, String serviceName, String fromResUid, String toResUid) {
 916
 917                 Either<ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>>, StorageOperationStatus> allResourceInstances = resourceInstanceOperation.getAllComponentInstances(serviceName, NodeTypeEnum.Service, NodeTypeEnum.Resource,
 918                                 true);
 919                 // assertTrue("check return code after get all resource instances",
 920                 // associateResourceInstances.isLeft());
 921                 ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>> immutablePair = allResourceInstances.left().value();
 922                 List<ComponentInstance> nodes = immutablePair.getKey();
 923                 List<RequirementCapabilityRelDef> edges = immutablePair.getValue();
 924                 assertEquals("check 2 nodes returned", 2, nodes.size());
 925                 assertEquals("check one relation returned", 1, edges.size());
 926                 RequirementCapabilityRelDef requirementCapabilityRelDef = edges.get(0);
 927                 assertEquals("check from node", requirementCapabilityRelDef.getFromNode(), fromResUid);
 928                 requirementCapabilityRelDef.getToNode();
 929                 assertEquals("check to node", requirementCapabilityRelDef.getToNode(), toResUid);
 930                 int size = requirementCapabilityRelDef.getRelationships().size();
 931                 assertEquals("check number of relations", 2, size);
 932                 String req1 = requirementCapabilityRelDef.getRelationships().get(0).getRequirement();
 933                 String req2 = requirementCapabilityRelDef.getRelationships().get(1).getRequirement();
 934
 935                 List<String> requirements = new ArrayList<String>();
 936                 requirements.add(req1);
 937                 requirements.add(req2);
 938
 939                 assertTrue("check requirement returned " + reqName1, requirements.contains(reqName1));
 940                 assertTrue("check requirement returned " + reqName2, requirements.contains(reqName2));
 941
 942                 String nodesStr = prettyGson.toJson(nodes);
 943                 String edgesStr = prettyGson.toJson(edges);
 944
 945                 log.debug(nodesStr);
 946                 log.debug(edgesStr);
 947         }
 948
 949         private Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource(String capabilityTypeName1, String reqName1, String reqNodeName, String reqRelationship, Resource softwareComponent) {
 950                 RequirementDefinition reqDefinition1 = new RequirementDefinition();
 951                 reqDefinition1.setNode(reqNodeName);
 952                 reqDefinition1.setRelationship(reqRelationship);
 953                 reqDefinition1.setCapability(capabilityTypeName1);
 954                 // add requirement to software component
 955                 Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = requirementOperation.addRequirementToResource(reqName1, reqDefinition1, softwareComponent.getUniqueId(), true);
 956                 assertEquals("check requirement was added", true, addRequirementToResource.isLeft());
 957                 return addRequirementToResource;
 958         }
 959
 960         private CapabilityDefinition addCapabilityToResource(String capabilityTypeName1, String reqName1, Resource computeComponent) {
 961                 CapabilityDefinition capabilityDefinition1 = new CapabilityDefinition();
 962                 capabilityDefinition1.setDescription("my capability");
 963                 capabilityDefinition1.setType(capabilityTypeName1);
 964                 List<String> validSourceTypes = new ArrayList<String>();
 965                 validSourceTypes.add("tosca.nodes.SC");
 966                 capabilityDefinition1.setValidSourceTypes(validSourceTypes);
 967                 Either<CapabilityDefinition, StorageOperationStatus> addCapability = capabilityOperation.addCapability(computeComponent.getUniqueId(), reqName1, capabilityDefinition1, true);
 968                 assertTrue("check capability created ", addCapability.isLeft());
 969                 return addCapability.left().value();
 970         }
 971
 972         @Test
 973         @Ignore
 974         public void testConnectResourceInstancesCapabilityNameDiffFromReqName() {
 975
 976                 PrintGraph printGraph1 = new PrintGraph();
 977                 int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
 978
 979                 try {
 980
 981                         String capabilityTypeName = CAPABILITY_2;
 982                         String reqName = "host";
 983                         String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
 984                         String rootName = "Root2" + TEST_CLASS_NUMBER;
 985                         String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
 986                         String computeNodeName = reqNodeName;
 987                         String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
 988                         String reqRelationship = "myrelationship";
 989
 990                         String DIFFERENT_CAPABILITY = "hostDiffernet";
 991
 992                         // Create Capability type
 993                         CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
 994                         capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
 995                         CapabilityTypeDefinition createCapabilityDef = capabilityTypeOperationTest.createCapability(capabilityTypeName);
 996
 997                         ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
 998                         resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
 999
1000                         // create root resource
1001                         Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null, true, true);
1002                         ResourceMetadataData resourceData = new ResourceMetadataData();
1003                         resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
1004                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1005                         Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1006                         assertTrue(updateNode.isLeft());
1007
1008                         Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation.getResource(rootResource.getUniqueId(), true);
1009
1010                         String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
1011                         log.debug(rootResourceJson);
1012
1013                         // create software component
1014                         Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName, "1.0", rootResource.getName(), true, true);
1015
1016                         resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
1017                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1018                         updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1019                         assertTrue(updateNode.isLeft());
1020
1021                         // create compute component
1022                         Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName, "1.0", rootResource.getName(), true, true);
1023
1024                         CapabilityDefinition capabilty = addCapabilityToResource(capabilityTypeName, DIFFERENT_CAPABILITY, computeComponent);
1025
1026                         // create requirement definition
1027
1028                         Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(capabilityTypeName, reqName, reqNodeName, reqRelationship, softwareComponent);
1029
1030                         String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
1031
1032                         // create my resource derived from software component
1033                         Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource", myResourceVersion, softwareComponent.getName(), true, true);
1034
1035                         String serviceName = "myservice.1.0";
1036                         List<ComponentInstance> resInstances = buildServiceAndConnectBetweenResourceInstances(serviceName, resource, computeComponent, "host", false, capabilty.getUniqueId(), parentReqUniqId);
1037
1038                         PrintGraph printGraph = new PrintGraph();
1039                         String webGraph = printGraph.buildGraphForWebgraphWiz(titanDao.getGraph().left().value());
1040                 } finally {
1041                         rollbackAndPrint();
1042
1043                         compareGraphSize(numberOfVertices);
1044                 }
1045
1046         }
1047
1048         @Test
1049         @Ignore
1050         public void testConnectResourceInstancesInvalidCapability() {
1051
1052                 PrintGraph printGraph1 = new PrintGraph();
1053                 int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
1054
1055                 try {
1056
1057                         String capabilityTypeName = CAPABILITY_2;
1058                         String reqName = "host";
1059                         String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
1060                         String rootName = "Root2" + TEST_CLASS_NUMBER;
1061                         String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
1062                         String computeNodeName = reqNodeName;
1063                         String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
1064                         String reqRelationship = "myrelationship";
1065
1066                         String capabilityTypeNameOther = CAPABILITY_2 + "othertype";
1067
1068                         String DIFFERENT_CAPABILITY = "hostDiffernet";
1069
1070                         // Create Capability type
1071                         CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
1072                         capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
1073                         CapabilityTypeDefinition createCapabilityDef = capabilityTypeOperationTest.createCapability(capabilityTypeName);
1074
1075                         CapabilityTypeDefinition createCapabilityDef2 = capabilityTypeOperationTest.createCapability(capabilityTypeNameOther);
1076
1077                         ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
1078                         resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
1079
1080                         // create root resource
1081                         Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null, true, true);
1082                         ResourceMetadataData resourceData = new ResourceMetadataData();
1083                         resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
1084                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1085                         Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1086                         assertTrue(updateNode.isLeft());
1087
1088                         Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation.getResource(rootResource.getUniqueId(), true);
1089
1090                         String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
1091                         log.debug(rootResourceJson);
1092
1093                         // create software component
1094                         Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName, "1.0", rootResource.getName(), true, true);
1095
1096                         resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
1097                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1098                         updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1099                         assertTrue(updateNode.isLeft());
1100
1101                         // create compute component
1102                         Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName, "1.0", rootResource.getName(), true, true);
1103
1104                         addCapabilityToResource(capabilityTypeName, DIFFERENT_CAPABILITY, computeComponent);
1105
1106                         // create requirement definition
1107
1108                         Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(capabilityTypeNameOther, reqName, reqNodeName, reqRelationship, softwareComponent);
1109
1110                         String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
1111
1112                         // create my resource derived from software component
1113                         Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource", myResourceVersion, softwareComponent.getName(), true, true);
1114
1115                         String serviceName = "myservice.1.0";
1116                         List<ComponentInstance> resInstances = buildServiceAndConnectBetweenResourceInstancesWithError(serviceName, resource, computeComponent, "host", false, TitanOperationStatus.ILLEGAL_ARGUMENT);
1117
1118                         PrintGraph printGraph = new PrintGraph();
1119                         String webGraph = printGraph.buildGraphForWebgraphWiz(titanDao.getGraph().left().value());
1120                         log.debug(webGraph);
1121
1122                 } finally {
1123                         rollbackAndPrint();
1124
1125                         compareGraphSize(numberOfVertices);
1126                 }
1127
1128         }
1129
1130         private void compareGraphSize(int numberOfVertices, Set<String> toRemoveFromSet) {
1131                 PrintGraph printGraph2 = new PrintGraph();
1132                 int numberOfVerticesCurr = printGraph2.getNumberOfVertices(titanDao.getGraph().left().value());
1133
1134                 Set<String> set = printGraph2.getVerticesSet(titanDao.getGraph().left().value());
1135                 if (toRemoveFromSet != null) {
1136                         set.removeAll(toRemoveFromSet);
1137                 }
1138
1139                 assertEquals("check all data deleted from graph " + set, numberOfVertices, numberOfVerticesCurr);
1140         }
1141
1142         private void compareGraphSize(int numberOfVertices) {
1143                 PrintGraph printGraph2 = new PrintGraph();
1144                 int numberOfVerticesCurr = printGraph2.getNumberOfVertices(titanDao.getGraph().left().value());
1145
1146                 assertEquals("check all data deleted from graph " + printGraph2.getVerticesSet(titanDao.getGraph().left().value()), numberOfVertices, numberOfVerticesCurr);
1147         }
1148
1149         @Test
1150         @Ignore
1151         public void testConnectResourceInstancesRequirementNotFound() {
1152
1153                 PrintGraph printGraph1 = new PrintGraph();
1154                 int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
1155                 try {
1156
1157                         String capabilityTypeName = CAPABILITY_2;
1158                         String reqName = "host";
1159                         String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
1160                         String rootName = "Root2" + TEST_CLASS_NUMBER;
1161                         String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
1162                         String computeNodeName = reqNodeName;
1163                         String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
1164                         String reqRelationship = "myrelationship";
1165
1166                         String DIFFERENT_CAPABILITY = "hostDiffernet";
1167
1168                         // Create Capability type
1169                         CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
1170                         capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
1171                         CapabilityTypeDefinition createCapabilityDef = capabilityTypeOperationTest.createCapability(capabilityTypeName);
1172
1173                         ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
1174                         resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
1175
1176                         // create root resource
1177                         Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null, true, true);
1178                         ResourceMetadataData resourceData = new ResourceMetadataData();
1179                         resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
1180                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1181                         Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1182                         assertTrue(updateNode.isLeft());
1183
1184                         Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation.getResource(rootResource.getUniqueId(), true);
1185
1186                         String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
1187                         log.debug(rootResourceJson);
1188
1189                         // create software component
1190                         Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName, "1.0", rootResource.getName(), true, true);
1191
1192                         resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
1193                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1194                         updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1195                         assertTrue(updateNode.isLeft());
1196
1197                         // create compute component
1198                         Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName, "1.0", rootResource.getName(), true, true);
1199
1200                         addCapabilityToResource(capabilityTypeName, reqName, computeComponent);
1201
1202                         // create requirement definition
1203
1204                         RequirementDefinition reqDefinition = new RequirementDefinition();
1205                         reqDefinition.setNode(reqNodeName);
1206                         reqDefinition.setRelationship(reqRelationship);
1207                         reqDefinition.setCapability(capabilityTypeName);
1208                         // add requirement to software component
1209                         Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = requirementOperation.addRequirementToResource(reqName + "ssssssss", reqDefinition, softwareComponent.getUniqueId(), true);
1210                         assertEquals("check requirement was added", true, addRequirementToResource.isLeft());
1211
1212                         String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
1213
1214                         // create my resource derived from software component
1215                         Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource", myResourceVersion, softwareComponent.getName(), true, true);
1216
1217                         String serviceName = "myservice.1.0";
1218                         List<ComponentInstance> resInstances = buildServiceAndConnectBetweenResourceInstancesWithError(serviceName, resource, computeComponent, "host", false, TitanOperationStatus.ILLEGAL_ARGUMENT);
1219
1220                         PrintGraph printGraph = new PrintGraph();
1221                         String webGraph = printGraph.buildGraphForWebgraphWiz(titanDao.getGraph().left().value());
1222                         log.debug(webGraph);
1223
1224                 } finally {
1225                         titanDao.rollback();
1226
1227                         compareGraphSize(numberOfVertices);
1228                 }
1229
1230         }
1231
1232         private void disconnectResourcesInService(String serviceName, RequirementCapabilityRelDef reqCapDef) {
1233
1234                 Either<List<RelationshipInstData>, TitanOperationStatus> disconnectResourcesInService = resourceInstanceOperation.disconnectResourcesInService(serviceName, NodeTypeEnum.Service, reqCapDef);
1235                 assertTrue("check relatioship instance was deleted", disconnectResourcesInService.isLeft());
1236
1237                 disconnectResourcesInService = resourceInstanceOperation.disconnectResourcesInService(serviceName, NodeTypeEnum.Service, reqCapDef);
1238                 assertTrue("check relatioship instance already was deleted", disconnectResourcesInService.isRight());
1239                 assertEquals("check relatioship instance already was deleted. status NOT_FOUND", TitanOperationStatus.NOT_FOUND, disconnectResourcesInService.right().value());
1240         }
1241
1242         private List<ComponentInstance> buildServiceAndConnectBetweenResourceInstancesWithError(String serviceName, Resource resource, Resource computeComponent, String requirement, boolean ignoreCreatingService,
1243                         TitanOperationStatus titanOperationStatus) {
1244
1245                 String serviceId = "myservice.1.0";
1246
1247                 if (false == ignoreCreatingService) {
1248                         ServiceMetadataData createService = createService(serviceId);
1249                 }
1250                 ComponentInstance myresourceInstance = buildResourceInstance(resource.getUniqueId(), "1", resource.getName());
1251
1252                 ComponentInstance computeInstance = buildResourceInstance(computeComponent.getUniqueId(), "2", computeComponent.getName());
1253
1254                 Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true, myresourceInstance, NodeTypeEnum.Resource, false);
1255                 assertTrue("check instance added to service", myinstanceRes.isLeft());
1256                 ComponentInstance value1 = myinstanceRes.left().value();
1257                 Either<ComponentInstance, TitanOperationStatus> computeInstTes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "2", true, computeInstance, NodeTypeEnum.Resource, false);
1258                 assertTrue("check instance added to service", computeInstTes.isLeft());
1259                 ComponentInstance value2 = computeInstTes.left().value();
1260
1261                 RequirementAndRelationshipPair relationPair = new RequirementAndRelationshipPair();
1262                 relationPair.setRequirement(requirement);
1263
1264                 Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService = resourceInstanceOperation.connectResourcesInService(serviceId, NodeTypeEnum.Service, value1.getUniqueId(), value2.getUniqueId(), relationPair);
1265
1266                 assertTrue("check relation was not created", connectResourcesInService.isRight());
1267                 assertEquals("check error code after connect resource instances failed", titanOperationStatus, connectResourcesInService.right().value());
1268
1269                 List<ComponentInstance> resInstances = new ArrayList<ComponentInstance>();
1270                 resInstances.add(value1);
1271
1272                 return resInstances;
1273
1274         }
1275
1276         private List<ComponentInstance> buildServiceAndConnectBetweenResourceInstances(String serviceName, Resource resource, Resource computeComponent, String requirement, boolean ignoreCreatingService, String capabilityId, String requirementId) {
1277
1278                 String serviceId = "myservice.1.0";
1279
1280                 if (false == ignoreCreatingService) {
1281                         ServiceMetadataData createService = createService(serviceId);
1282                 }
1283                 ComponentInstance myresourceInstance = buildResourceInstance(resource.getUniqueId(), "1", resource.getName());
1284
1285                 ComponentInstance computeInstance = buildResourceInstance(computeComponent.getUniqueId(), "2", computeComponent.getName());
1286
1287                 Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true, myresourceInstance, NodeTypeEnum.Resource, false);
1288                 assertTrue("check instance added to service", myinstanceRes.isLeft());
1289                 ComponentInstance value1 = myinstanceRes.left().value();
1290                 Either<ComponentInstance, TitanOperationStatus> computeInstTes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "2", true, computeInstance, NodeTypeEnum.Resource, false);
1291                 assertTrue("check instance added to service", computeInstTes.isLeft());
1292                 ComponentInstance value2 = computeInstTes.left().value();
1293                 RequirementAndRelationshipPair relationPair = new RequirementAndRelationshipPair();
1294                 relationPair.setRequirement(requirement);
1295
1296                 relationPair.setCapabilityUid(capabilityId);
1297                 relationPair.setRequirementUid(requirementId);
1298                 relationPair.setRequirementOwnerId(value1.getUniqueId());
1299                 relationPair.setCapabilityOwnerId(value2.getUniqueId());
1300
1301                 Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService = resourceInstanceOperation.connectResourcesInService(serviceId, NodeTypeEnum.Service, value1.getUniqueId(), value2.getUniqueId(), relationPair);
1302
1303                 assertTrue("check relation created", connectResourcesInService.isLeft());
1304
1305                 List<ComponentInstance> resInstances = new ArrayList<ComponentInstance>();
1306                 resInstances.add(value1);
1307                 resInstances.add(value2);
1308
1309                 return resInstances;
1310
1311         }
1312
1313         @Test
1314         @Ignore
1315         public void getAllResourceInstancesThree() {
1316
1317                 PrintGraph printGraph1 = new PrintGraph();
1318                 int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
1319                 try {
1320
1321                         Set<String> vertexSetBeforeMethod = printGraph1.getVerticesSet(titanDao.getGraph().left().value());
1322
1323                         String capabilityTypeName = CAPABILITY_2;
1324                         String reqName = "host";
1325                         String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
1326                         String rootName = "Root2" + TEST_CLASS_NUMBER;
1327                         String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
1328                         String computeNodeName = reqNodeName;
1329                         String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
1330                         String reqRelationship = "myrelationship";
1331
1332                         // Create Capability type
1333                         CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
1334                         capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
1335                         CapabilityTypeDefinition createCapabilityDef = capabilityTypeOperationTest.createCapability(capabilityTypeName);
1336
1337                         ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
1338                         resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
1339
1340                         // create root resource
1341                         Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null, true, true);
1342                         ResourceMetadataData resourceData = new ResourceMetadataData();
1343                         resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
1344                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1345                         Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1346                         assertTrue(updateNode.isLeft());
1347
1348                         Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation.getResource(rootResource.getUniqueId(), true);
1349
1350                         String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
1351                         log.debug(rootResourceJson);
1352
1353                         // create software component
1354                         Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName, "1.0", rootResource.getName(), true, true);
1355
1356                         resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
1357                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1358                         updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1359                         assertTrue(updateNode.isLeft());
1360
1361                         // create compute component
1362                         Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName, "1.0", rootResource.getName(), true, true);
1363
1364                         // rollbackAndPrint();
1365
1366                         // Add capabilities to Compute Resource
1367                         CapabilityDefinition capability = addCapabilityToResource(capabilityTypeName, "host", computeComponent);
1368
1369                         // create requirement definition
1370
1371                         Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(capabilityTypeName, reqName, reqNodeName, reqRelationship, softwareComponent);
1372
1373                         String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
1374
1375                         // create my resource derived from software component
1376                         Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource", myResourceVersion, softwareComponent.getName(), true, true);
1377
1378                         String serviceId = "myservice.1.0";
1379
1380                         ServiceMetadataData createService = createService(serviceId);
1381
1382                         Either<ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>>, StorageOperationStatus> allResourceInstances = resourceInstanceOperation.getAllComponentInstances(serviceId, NodeTypeEnum.Service, NodeTypeEnum.Resource,
1383                                         true);
1384                         assertTrue("check NOT_FOUND is returned", allResourceInstances.isRight());
1385                         assertEquals("check NOT_FOUND is returned", allResourceInstances.right().value(), StorageOperationStatus.NOT_FOUND);
1386
1387                         ComponentInstance myresourceInstance = buildResourceInstance(resource.getUniqueId(), "1", "my-resource");
1388                         myresourceInstance.setName("my-resource");
1389
1390                         ComponentInstance computeInstance1 = buildResourceInstance(computeComponent.getUniqueId(), "2", "tosca.nodes.Compute2");
1391
1392                         Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true, myresourceInstance, NodeTypeEnum.Resource, false);
1393                         assertTrue("check instance added to service", myinstanceRes.isLeft());
1394                         ComponentInstance value1 = myinstanceRes.left().value();
1395
1396                         allResourceInstances = resourceInstanceOperation.getAllComponentInstances(serviceId, NodeTypeEnum.Service, NodeTypeEnum.Resource, true);
1397                         assertTrue("check resource instances found", allResourceInstances.isLeft());
1398                         ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>> immutablePair = allResourceInstances.left().value();
1399                         List<ComponentInstance> nodes = immutablePair.getKey();
1400                         List<RequirementCapabilityRelDef> edges = immutablePair.getValue();
1401
1402                         assertEquals("check resource instances size", 1, nodes.size());
1403                         assertEquals("check resource instances size", 0, edges.size());
1404
1405                         Either<ComponentInstance, TitanOperationStatus> computeInstTes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "2", true, computeInstance1, NodeTypeEnum.Resource, false);
1406                         assertTrue("check instance added to service", computeInstTes.isLeft());
1407                         ComponentInstance value2 = computeInstTes.left().value();
1408
1409                         allResourceInstances = resourceInstanceOperation.getAllComponentInstances(serviceId, NodeTypeEnum.Service, NodeTypeEnum.Resource, true);
1410                         assertTrue("check resource instances found", allResourceInstances.isLeft());
1411                         immutablePair = allResourceInstances.left().value();
1412                         nodes = immutablePair.getKey();
1413                         edges = immutablePair.getValue();
1414
1415                         assertEquals("check resource instances size", 2, nodes.size());
1416                         assertEquals("check resource instances size", 0, edges.size());
1417
1418                         String requirement = "host";
1419                         RequirementAndRelationshipPair relationPair = new RequirementAndRelationshipPair();
1420                         relationPair.setRequirement(requirement);
1421                         relationPair.setCapabilityUid(capability.getUniqueId());
1422                         relationPair.setRequirementUid(addRequirementToResource.left().value().getUniqueId());
1423                         relationPair.setRequirementOwnerId(value1.getUniqueId());
1424                         relationPair.setCapabilityOwnerId(value2.getUniqueId());
1425
1426                         Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService = resourceInstanceOperation.connectResourcesInService(serviceId, NodeTypeEnum.Service, value1.getUniqueId(), value2.getUniqueId(), relationPair);
1427
1428                         assertTrue("check relation created", connectResourcesInService.isLeft());
1429
1430                         allResourceInstances = resourceInstanceOperation.getAllComponentInstances(serviceId, NodeTypeEnum.Service, NodeTypeEnum.Resource, true);
1431                         assertTrue("check resource instances found", allResourceInstances.isLeft());
1432                         immutablePair = allResourceInstances.left().value();
1433                         nodes = immutablePair.getKey();
1434                         edges = immutablePair.getValue();
1435
1436                         assertEquals("check resource instances size", 2, nodes.size());
1437                         assertEquals("check resource instances size", 1, edges.size());
1438
1439                         List<ComponentInstance> resInstances2 = new ArrayList<ComponentInstance>();
1440                         resInstances2.add(value1);
1441                         resInstances2.add(value2);
1442
1443                         ComponentInstance myresourceInstance2 = buildResourceInstance(resource.getUniqueId(), "1", "myresource2");
1444
1445                         Either<ComponentInstance, TitanOperationStatus> newResource = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "3", true, myresourceInstance2, NodeTypeEnum.Resource, false);
1446
1447                         assertTrue("added resource instance successfully", newResource.isLeft());
1448
1449                         relationPair.setRequirement(requirement);
1450                         relationPair.setRequirementOwnerId(newResource.left().value().getUniqueId());
1451
1452                         Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService2 = resourceInstanceOperation.connectResourcesInService(serviceId, NodeTypeEnum.Service, newResource.left().value().getUniqueId(), value2.getUniqueId(),
1453                                         relationPair);
1454                         assertTrue("check resource instance was added to service", connectResourcesInService2.isLeft());
1455
1456                         allResourceInstances = resourceInstanceOperation.getAllComponentInstances(serviceId, NodeTypeEnum.Service, NodeTypeEnum.Resource, true);
1457                         assertTrue("check resource instances found", allResourceInstances.isLeft());
1458                         immutablePair = allResourceInstances.left().value();
1459                         nodes = immutablePair.getKey();
1460                         edges = immutablePair.getValue();
1461
1462                         assertEquals("check resource instances size", 3, nodes.size());
1463                         assertEquals("check resource instances size", 2, edges.size());
1464
1465                         Either<List<ComponentInstance>, TitanOperationStatus> deleteAllResourceInstancesOfService = resourceInstanceOperation.deleteAllComponentInstancesInternal(serviceId, NodeTypeEnum.Service);
1466                         assertTrue("check resource instances was deleted.", deleteAllResourceInstancesOfService.isLeft());
1467                         assertEquals("check number of deleted resource instances.", 3, deleteAllResourceInstancesOfService.left().value().size());
1468
1469                         Either<List<RelationshipInstData>, TitanOperationStatus> allRelatinshipInst = titanDao.getAll(NodeTypeEnum.RelationshipInst, RelationshipInstData.class);
1470                         assertTrue("allRelatinshipInst is empty", allRelatinshipInst.isRight());
1471                         assertEquals("allRelatinshipInst result is NOT_FOUND", TitanOperationStatus.NOT_FOUND, allRelatinshipInst.right().value());
1472
1473                         Either<Resource, StorageOperationStatus> deleteComputeResource = resourceOperation.deleteResource(computeComponent.getUniqueId(), true);
1474                         assertTrue("delete compute resource succeed", deleteComputeResource.isLeft());
1475
1476                         Either<Resource, StorageOperationStatus> deleteSCResource = resourceOperation.deleteResource(softwareComponent.getUniqueId(), true);
1477                         assertTrue("delete software component resource succeed", deleteSCResource.isLeft());
1478
1479                         Either<Resource, StorageOperationStatus> deleteMyResource = resourceOperation.deleteResource(resource.getUniqueId(), true);
1480                         assertTrue("delete my resource succeed", deleteMyResource.isLeft());
1481
1482                         Either<Resource, StorageOperationStatus> rootResourceDeleted = resourceOperation.deleteResource(rootResource.getUniqueId(), true);
1483                         assertTrue("delete root resource succeed", rootResourceDeleted.isLeft());
1484
1485                         Set<String> vertexSetAfterDelete = printGraph1.getVerticesSet(titanDao.getGraph().left().value());
1486
1487                         vertexSetAfterDelete.removeAll(vertexSetBeforeMethod);
1488
1489                         log.debug("vertexSetAfterDelete={}", vertexSetAfterDelete);
1490                         log.debug("vertexSetAfterDelete size={}", vertexSetAfterDelete.size());
1491
1492                         // int numberOfVerticesAfterOperation =
1493                         // printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
1494                         // System.out.println(numberOfVerticesAfterOperation);
1495                         // 6 - service, 2 tags, capability + 2 parameters
1496                         // compareGraphSize(numberOfVertices + 6, vertexSetBeforeMethod);
1497
1498                 } finally {
1499                         rollbackAndPrint(false);
1500                         compareGraphSize(numberOfVertices);
1501                         // printGraph1.printGraphVertices(titanDao.getGraph().left().value());
1502                 }
1503
1504         }
1505
1506         public void testCreateRootResource() {
1507
1508                 String name = "tosca.nodes.Root";
1509
1510                 String state = LifecycleStateEnum.CERTIFIED.name();
1511
1512                 ResourceMetadataData resourceData1 = new ResourceMetadataData();
1513                 resourceData1.getMetadataDataDefinition().setUniqueId(UniqueIdBuilder.buildResourceUniqueId());
1514                 resourceData1.getMetadataDataDefinition().setName(name);
1515                 resourceData1.getMetadataDataDefinition().setState(state);
1516                 resourceData1.getMetadataDataDefinition().setHighestVersion(true);
1517                 resourceData1.getMetadataDataDefinition().setContactId("contactId");
1518                 Either<ResourceMetadataData, TitanOperationStatus> createNode1 = titanDao.createNode(resourceData1, ResourceMetadataData.class);
1519
1520                 log.debug("{}", createNode1);
1521
1522                 titanDao.commit();
1523         }
1524
1525         public void testMultiResourceCertified() {
1526                 boolean create = true;
1527                 String name = "myresource7";
1528                 if (create) {
1529
1530                         String state = LifecycleStateEnum.CERTIFIED.name();
1531                         boolean isHighestVersion = true;
1532
1533                         ResourceMetadataData resourceData1 = new ResourceMetadataData();
1534                         resourceData1.getMetadataDataDefinition().setUniqueId(name + "." + "1.0");
1535                         resourceData1.getMetadataDataDefinition().setName(name);
1536                         resourceData1.getMetadataDataDefinition().setState(state);
1537                         resourceData1.getMetadataDataDefinition().setHighestVersion(true);
1538                         resourceData1.getMetadataDataDefinition().setContactId("contactId");
1539                         Either<ResourceMetadataData, TitanOperationStatus> createNode1 = titanDao.createNode(resourceData1, ResourceMetadataData.class);
1540
1541                         log.debug("{}", createNode1);
1542
1543                         titanDao.commit();
1544
1545                         // resourceData1.setUniqueId(name + "." + "2.0");
1546                         // resourceData1.setHighestVersion(true);
1547                         // resourceData1.setContactId("contactId");
1548                         //
1549                         // Either<ResourceData, TitanOperationStatus> createNode2 = titanDao
1550                         // .createNode(resourceData1, ResourceData.class);
1551                         // System.out.println(createNode2);
1552                         //
1553                         // titanDao.commit();
1554
1555                         // resourceData1.setHighestVersion(false);
1556                         resourceData1.getMetadataDataDefinition().setContactId("222contactId222");
1557                         Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData1, ResourceMetadataData.class);
1558
1559                         titanDao.commit();
1560
1561                         // TitanGraph titanGraph = titanDao.getGraph().left().value();
1562                         // Iterable<Result<Vertex>> vertices =
1563                         // titanGraph.indexQuery("highestVersion",
1564                         // "v.highestVersion:true").vertices();
1565                         // for (Result<Vertex> vertex : vertices) {
1566                         // Vertex element = vertex.getElement();
1567                         // System.out.println( ElementHelper.getProperties(element));
1568                         // }
1569
1570                 }
1571
1572                 Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = searchForResource(name);
1573
1574                 log.debug("{}", byCriteria.left().value().size());
1575
1576                 byCriteria = searchForResource(name);
1577
1578                 log.debug("{}", byCriteria.left().value().size());
1579
1580         }
1581
1582         private Either<List<ResourceMetadataData>, TitanOperationStatus> searchForResource(String name) {
1583                 Map<String, Object> propertiesToMatch = new HashMap<String, Object>();
1584                 propertiesToMatch.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFIED.name());
1585                 // propertiesToMatch.put(GraphPropertiesDictionary.IS_ABSTRACT.getProperty(),
1586                 // true);
1587                 propertiesToMatch.put(GraphPropertiesDictionary.NAME.getProperty(), name);
1588                 propertiesToMatch.put(GraphPropertiesDictionary.CONTACT_ID.getProperty(), "contactId");
1589                 // propertiesToMatch.put(GraphPropertiesDictionary.IS_HIGHEST_VERSION.getProperty(),
1590                 // true);
1591                 Either<List<ResourceMetadataData>, TitanOperationStatus> byCriteria = titanDao.getByCriteria(NodeTypeEnum.Resource, propertiesToMatch, ResourceMetadataData.class);
1592                 return byCriteria;
1593         }
1594
1595         @Test
1596         public void testCreateResourceInstanceTwice() {
1597
1598                 PrintGraph printGraph1 = new PrintGraph();
1599                 int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
1600                 try {
1601
1602                         String capabilityTypeName = CAPABILITY_2;
1603                         String reqName = "host";
1604                         String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
1605                         String rootName = "Root2" + TEST_CLASS_NUMBER;
1606                         String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
1607                         String computeNodeName = reqNodeName;
1608                         String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
1609                         String reqRelationship = "myrelationship";
1610
1611                         ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
1612                         resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
1613
1614                         // create root resource
1615                         Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null, true, true);
1616                         ResourceMetadataData resourceData = new ResourceMetadataData();
1617                         resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
1618                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1619                         Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1620                         assertTrue(updateNode.isLeft());
1621
1622                         Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation.getResource(rootResource.getUniqueId(), true);
1623
1624                         // create software component
1625                         Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName, "1.0", rootResource.getName(), true, true);
1626
1627                         resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
1628                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1629                         updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1630                         assertTrue(updateNode.isLeft());
1631
1632                         ComponentInstance myresourceInstance = buildResourceInstance(softwareComponent.getUniqueId(), "1", softwareCompName);
1633
1634                         String serviceName = "myservice.1.0";
1635                         ServiceMetadataData createService = createService(serviceName);
1636                         Either<ComponentInstance, StorageOperationStatus> myinstanceRes1 = resourceInstanceOperation.createComponentInstance(serviceName, NodeTypeEnum.Service, "1", myresourceInstance, NodeTypeEnum.Resource, true);
1637                         assertTrue("check resource instance was created", myinstanceRes1.isLeft());
1638
1639                         Either<ComponentInstance, StorageOperationStatus> myinstanceRes2 = resourceInstanceOperation.createComponentInstance(serviceName, NodeTypeEnum.Service, "1", myresourceInstance, NodeTypeEnum.Resource, true);
1640                         assertTrue("check resource instance was not created", myinstanceRes2.isRight());
1641                         assertEquals("check error code", StorageOperationStatus.SCHEMA_VIOLATION, myinstanceRes2.right().value());
1642
1643                         Either<ComponentInstance, StorageOperationStatus> deleteResourceInstance = resourceInstanceOperation.deleteComponentInstance(NodeTypeEnum.Service, serviceName, myinstanceRes1.left().value().getUniqueId(), true);
1644                         assertTrue("check resource instance was deleted", deleteResourceInstance.isLeft());
1645
1646                         deleteResourceInstance = resourceInstanceOperation.deleteComponentInstance(NodeTypeEnum.Service, serviceName, myinstanceRes1.left().value().getUniqueId(), true);
1647                         assertTrue("check resource instance was not deleted", deleteResourceInstance.isRight());
1648                         assertEquals("check resource instance was not deleted", StorageOperationStatus.NOT_FOUND, deleteResourceInstance.right().value());
1649
1650                 } finally {
1651                         rollbackAndPrint(false);
1652                         compareGraphSize(numberOfVertices);
1653                 }
1654
1655         }
1656
1657         @Test
1658         @Ignore
1659         public void testConnectResourceInstancesTwice() {
1660
1661                 PrintGraph printGraph1 = new PrintGraph();
1662                 int numberOfVertices = printGraph1.getNumberOfVertices(titanDao.getGraph().left().value());
1663
1664                 try {
1665
1666                         String capabilityTypeName1 = CAPABILITY_1;
1667                         String capabilityTypeName2 = CAPABILITY_2;
1668                         String reqName1 = "host1";
1669                         String reqName2 = "host2";
1670                         String reqNodeName = "tosca.nodes.Compute2" + TEST_CLASS_NUMBER;
1671                         String rootName = "Root2" + TEST_CLASS_NUMBER;
1672                         String softwareCompName = "tosca.nodes.SoftwareComponent2" + TEST_CLASS_NUMBER;
1673                         String computeNodeName = reqNodeName;
1674                         String myResourceVersion = "4.0" + TEST_CLASS_NUMBER;
1675                         String reqRelationship = "myrelationship";
1676
1677                         // Create Capability type
1678                         CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
1679                         capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
1680                         CapabilityTypeDefinition createCapabilityDef1 = capabilityTypeOperationTest.createCapability(capabilityTypeName1);
1681                         CapabilityTypeDefinition createCapabilityDef2 = capabilityTypeOperationTest.createCapability(capabilityTypeName2);
1682
1683                         ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
1684                         resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
1685
1686                         // create root resource
1687                         Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null, true, true);
1688
1689                         ResourceMetadataData resourceData = new ResourceMetadataData();
1690                         resourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
1691                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1692                         Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1693                         assertTrue(updateNode.isLeft());
1694
1695                         Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation.getResource(rootResource.getUniqueId(), true);
1696
1697                         String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
1698                         log.debug(rootResourceJson);
1699
1700                         // create software component
1701                         Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName, "1.0", rootResource.getName(), true, true);
1702
1703                         resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
1704                         resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1705                         updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1706                         assertTrue(updateNode.isLeft());
1707
1708                         // create compute component
1709                         Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName, "1.0", rootResource.getName(), true, true);
1710
1711                         // Add capabilities to Compute Resource
1712                         CapabilityDefinition capabilty1 = addCapabilityToResource(capabilityTypeName1, reqName1, computeComponent);
1713                         CapabilityDefinition capabilty2 = addCapabilityToResource(capabilityTypeName2, reqName2, computeComponent);
1714
1715                         // rollbackAndPrint();
1716
1717                         // create requirement definition
1718
1719                         Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(capabilityTypeName1, reqName1, reqNodeName, reqRelationship, softwareComponent);
1720
1721                         String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
1722
1723                         // create my resource derived from software component
1724                         Resource resource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, "my-resource", myResourceVersion, softwareComponent.getName(), true, true);
1725
1726                         String serviceId = "myservice.1.0";
1727
1728                         ServiceMetadataData createService = createService(serviceId);
1729                         ComponentInstance myresourceInstance = buildResourceInstance(resource.getUniqueId(), "1", "my-resource");
1730
1731                         ComponentInstance computeInstance = buildResourceInstance(computeComponent.getUniqueId(), "2", computeNodeName);
1732
1733                         Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true, myresourceInstance, NodeTypeEnum.Resource, false);
1734                         assertTrue("check instance added to service", myinstanceRes.isLeft());
1735                         ComponentInstance value1 = myinstanceRes.left().value();
1736                         Either<ComponentInstance, TitanOperationStatus> computeInstTes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "2", true, computeInstance, NodeTypeEnum.Resource, false);
1737                         assertTrue("check instance added to service", computeInstTes.isLeft());
1738                         ComponentInstance value2 = computeInstTes.left().value();
1739
1740                         RequirementCapabilityRelDef relation = new RequirementCapabilityRelDef();
1741                         String fromResUid = value1.getUniqueId();
1742                         String toResUid = value2.getUniqueId();
1743                         relation.setFromNode(fromResUid);
1744                         relation.setToNode(toResUid);
1745                         List<RequirementAndRelationshipPair> relationships = new ArrayList<RequirementAndRelationshipPair>();
1746                         RequirementAndRelationshipPair immutablePair1 = new RequirementAndRelationshipPair(reqName1, null);
1747                         immutablePair1.setCapabilityUid(capabilty1.getUniqueId());
1748                         immutablePair1.setRequirementUid(parentReqUniqId);
1749                         immutablePair1.setRequirementOwnerId(fromResUid);
1750                         immutablePair1.setCapabilityOwnerId(toResUid);
1751                         relationships.add(immutablePair1);
1752
1753                         relation.setRelationships(relationships);
1754
1755                         Either<RequirementCapabilityRelDef, StorageOperationStatus> connectResourcesInService = resourceInstanceOperation.associateResourceInstances(serviceId, NodeTypeEnum.Service, relation, true, false);
1756                         assertTrue("check association succeed", connectResourcesInService.isLeft());
1757
1758                         relationships.clear();
1759                         RequirementAndRelationshipPair immutablePair2 = new RequirementAndRelationshipPair(reqName2, null);
1760                         immutablePair2.setCapabilityUid(capabilty2.getUniqueId());
1761                         immutablePair2.setRequirementUid(parentReqUniqId);
1762                         relationships.add(immutablePair2);
1763
1764                         RequirementCapabilityRelDef firstRelation = connectResourcesInService.left().value();
1765                         connectResourcesInService = resourceInstanceOperation.associateResourceInstances(serviceId, NodeTypeEnum.Service, relation, true, false);
1766                         assertTrue("check association succeed", connectResourcesInService.isRight());
1767                         assertEquals("check association failed", StorageOperationStatus.MATCH_NOT_FOUND, connectResourcesInService.right().value());
1768
1769                         Either<RequirementCapabilityRelDef, StorageOperationStatus> disconnectResourcesInService = resourceInstanceOperation.dissociateResourceInstances(serviceId, NodeTypeEnum.Service, firstRelation, true);
1770
1771                         assertTrue("check dissociation succeed", disconnectResourcesInService.isLeft());
1772
1773                         disconnectResourcesInService = resourceInstanceOperation.dissociateResourceInstances(serviceId, NodeTypeEnum.Service, relation, true);
1774
1775                         assertTrue("check dissociation failed", disconnectResourcesInService.isRight());
1776                         assertEquals("check association failed", StorageOperationStatus.NOT_FOUND, disconnectResourcesInService.right().value());
1777                 } finally {
1778                         rollbackAndPrint();
1779                         compareGraphSize(numberOfVertices);
1780                 }
1781
1782         }
1783
1784         private Resource createComputeWithCapability(String capabilityTypeName, String computeNodeName, ResourceOperationTest resourceOperationTest, Resource rootResource) {
1785                 // create compute component
1786                 // String id = UniqueIdBuilder.buildResourceUniqueId(computeNodeName,
1787                 // "1.0");
1788                 // if (resourceOperation.getResource(id).isLeft()){
1789                 // resourceOperation.deleteResource(id);
1790                 // }
1791                 Either<List<Resource>, StorageOperationStatus> oldResource = resourceOperation.getResourceByNameAndVersion(computeNodeName, "1.0", false);
1792                 if (oldResource.isLeft()) {
1793                         for (Resource old : oldResource.left().value()) {
1794                                 if (old.getResourceType().equals(ResourceTypeEnum.VFC)) {
1795                                         resourceOperation.deleteResource(old.getUniqueId());
1796                                 }
1797                         }
1798
1799                 }
1800
1801                 Resource computeComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, computeNodeName, "1.0", rootResource.getName(), true, true);
1802
1803                 // rollbackAndPrint();
1804
1805                 // Add capabilities to Compute Resource
1806                 addCapabilityToResource(capabilityTypeName, "host", computeComponent);
1807                 return resourceOperation.getResource(computeComponent.getUniqueId()).left().value();
1808         }
1809
1810         private Resource createSoftwareComponentWithReq(String softwareCompName, ResourceOperationTest resourceOperationTest, Resource rootResource, String capabilityTypeName, String reqName, String reqRelationship, String reqNodeName) {
1811                 Either<ResourceMetadataData, TitanOperationStatus> updateNode;
1812                 ResourceMetadataData resourceData = new ResourceMetadataData();
1813                 // create software component
1814                 // String id = UniqueIdBuilder.buildResourceUniqueId(softwareCompName,
1815                 // "1.0");
1816                 // if (resourceOperation.getResource(id).isLeft()){
1817                 // resourceOperation.deleteResource(id);
1818                 // }
1819                 Either<List<Resource>, StorageOperationStatus> oldResource = resourceOperation.getResourceByNameAndVersion(softwareCompName, "1.0", false);
1820                 if (oldResource.isLeft()) {
1821                         if (oldResource.isLeft()) {
1822                                 for (Resource old : oldResource.left().value()) {
1823                                         if (old.getResourceType().equals(ResourceTypeEnum.VFC)) {
1824                                                 resourceOperation.deleteResource(old.getUniqueId());
1825                                         }
1826                                 }
1827
1828                         }
1829                 }
1830
1831                 Resource softwareComponent = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, softwareCompName, "1.0", rootResource.getName(), true, true);
1832
1833                 resourceData.getMetadataDataDefinition().setUniqueId(softwareComponent.getUniqueId());
1834                 resourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1835                 updateNode = titanDao.updateNode(resourceData, ResourceMetadataData.class);
1836                 assertTrue(updateNode.isLeft());
1837
1838                 Either<RequirementDefinition, StorageOperationStatus> addRequirementToResource = addRequirementToResource(capabilityTypeName, reqName, reqNodeName, reqRelationship, softwareComponent);
1839
1840                 String parentReqUniqId = addRequirementToResource.left().value().getUniqueId();
1841
1842                 return resourceOperation.getResource(softwareComponent.getUniqueId()).left().value();
1843         }
1844
1845         private Resource createRootResource(String rootName, ResourceOperationTest resourceOperationTest) {
1846                 // create root resource
1847                 // String rootId = UniqueIdBuilder.buildResourceUniqueId(rootName,
1848                 // "1.0");
1849                 Either<List<Resource>, StorageOperationStatus> oldResource = resourceOperation.getResourceByNameAndVersion(rootName, "1.0", false);
1850                 if (oldResource.isLeft()) {
1851                         for (Resource old : oldResource.left().value()) {
1852                                 if (old.getResourceType().equals(ResourceTypeEnum.VFC)) {
1853                                         resourceOperation.deleteResource(old.getUniqueId());
1854                                 }
1855                         }
1856
1857                 }
1858                 Resource rootResource = resourceOperationTest.createResource(USER_ID, CATEGORY_NAME, rootName, "1.0", null, true, true);
1859                 ResourceMetadataData rootResourceData = new ResourceMetadataData();
1860                 rootResourceData.getMetadataDataDefinition().setUniqueId(rootResource.getUniqueId());
1861                 rootResourceData.getMetadataDataDefinition().setState(LifecycleStateEnum.CERTIFIED.name());
1862                 Either<ResourceMetadataData, TitanOperationStatus> updateNode = titanDao.updateNode(rootResourceData, ResourceMetadataData.class);
1863                 assertTrue(updateNode.isLeft());
1864
1865                 Either<Resource, StorageOperationStatus> fetchRootResource = resourceOperation.getResource(rootResource.getUniqueId(), true);
1866
1867                 String rootResourceJson = prettyGson.toJson(fetchRootResource.left().value());
1868                 log.debug(rootResourceJson);
1869                 return rootResource;
1870         }
1871
1872         public void addResourceInstancesAndRelation(String serviceId) {
1873
1874                 String rootName = "tosca.nodes.test.root";
1875                 String softwareCompName = "tosca.nodes.test.softwarecomponent";
1876                 String capabilityTypeName = "myCapability";
1877                 String reqName = "host";
1878                 String computeNodeName = "tosca.nodes.test.compute";
1879                 String reqRelationship = "myRelationship";
1880
1881                 ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
1882                 resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
1883
1884                 Resource rootResource = createRootResource(rootName, resourceOperationTest);
1885                 // Create Capability type
1886                 CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
1887                 capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
1888                 CapabilityTypeDefinition createCapabilityDef = capabilityTypeOperationTest.createCapability(capabilityTypeName);
1889
1890                 Resource softwareComponentResource = createSoftwareComponentWithReq(softwareCompName, resourceOperationTest, rootResource, capabilityTypeName, reqName, reqRelationship, computeNodeName);
1891                 Resource compute = createComputeWithCapability(capabilityTypeName, computeNodeName, resourceOperationTest, rootResource);
1892
1893                 // resource1
1894                 ComponentInstance myresourceInstance = buildResourceInstance(softwareComponentResource.getUniqueId(), "1", "tosca.nodes.test.root");
1895
1896                 Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true, myresourceInstance, NodeTypeEnum.Resource, false);
1897
1898                 assertTrue("check instance added to service", myinstanceRes.isLeft());
1899
1900                 // resource2
1901                 ComponentInstance computeInstance = buildResourceInstance(compute.getUniqueId(), "2", "tosca.nodes.test.compute");
1902                 ComponentInstance value1 = myinstanceRes.left().value();
1903
1904                 Either<ComponentInstance, TitanOperationStatus> computeInstTes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "2", true, computeInstance, NodeTypeEnum.Resource, false);
1905                 assertTrue("check instance added to service", computeInstTes.isLeft());
1906                 ComponentInstance value2 = computeInstTes.left().value();
1907
1908                 RequirementAndRelationshipPair relationPair = new RequirementAndRelationshipPair();
1909                 relationPair.setRequirement(reqName);
1910                 relationPair.setCapability(capabilityTypeName);
1911
1912                 String capId = "";
1913                 Map<String, List<CapabilityDefinition>> capabilities = compute.getCapabilities();
1914                 for (Map.Entry<String, List<CapabilityDefinition>> entry : capabilities.entrySet()) {
1915                         capId = entry.getValue().get(0).getUniqueId();
1916                 }
1917                 relationPair.setCapabilityUid(capId);
1918                 Map<String, List<RequirementDefinition>> requirements = softwareComponentResource.getRequirements();
1919                 String reqId = "";
1920                 for (Map.Entry<String, List<RequirementDefinition>> entry : requirements.entrySet()) {
1921                         reqId = entry.getValue().get(0).getUniqueId();
1922                 }
1923                 relationPair.setRequirementUid(reqId);
1924                 relationPair.setRequirementOwnerId(value1.getUniqueId());
1925                 relationPair.setCapabilityOwnerId(value2.getUniqueId());
1926                 relationPair.setCapabilityUid(capId);
1927
1928                 Either<RelationshipInstData, TitanOperationStatus> connectResourcesInService = resourceInstanceOperation.connectResourcesInService(serviceId, NodeTypeEnum.Service, value1.getUniqueId(), value2.getUniqueId(), relationPair);
1929
1930                 assertTrue("check relation created", connectResourcesInService.isLeft());
1931
1932         }
1933
1934         @Test
1935         @Ignore
1936         public void addResourceInstancesResourceDeleted() {
1937
1938                 String rootName = "tosca.nodes.test.root";
1939                 String softwareCompName = "tosca.nodes.test.softwarecomponent";
1940                 String capabilityTypeName = "myCapability";
1941                 String reqName = "host";
1942                 String computeNodeName = "tosca.nodes.test.compute";
1943                 String reqRelationship = "myRelationship";
1944
1945                 ServiceMetadataData origService = createService("myService");
1946                 String serviceId = (String) origService.getUniqueId();
1947
1948                 ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
1949                 resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
1950
1951                 Resource rootResource = createRootResource(rootName, resourceOperationTest);
1952                 // Create Capability type
1953                 CapabilityTypeOperationTest capabilityTypeOperationTest = new CapabilityTypeOperationTest();
1954                 capabilityTypeOperationTest.setOperations(titanDao, capabilityTypeOperation);
1955                 capabilityTypeOperationTest.createCapability(capabilityTypeName);
1956
1957                 Resource softwareComponentResource = createSoftwareComponentWithReq(softwareCompName, resourceOperationTest, rootResource, capabilityTypeName, reqName, reqRelationship, computeNodeName);
1958
1959                 deleteResource(softwareComponentResource.getUniqueId());
1960
1961                 // resource1
1962                 ComponentInstance myresourceInstance = buildResourceInstance(softwareComponentResource.getUniqueId(), "1", "tosca.nodes.test.root");
1963
1964                 Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true, myresourceInstance, NodeTypeEnum.Resource, false);
1965
1966                 assertTrue("check instance not added to service", myinstanceRes.isRight());
1967
1968         }
1969
1970         @Test
1971         @Ignore
1972         public void testDeploymentArtifactsOnRI() {
1973
1974                 String rootName = "tosca.nodes.test.root";
1975
1976                 ServiceMetadataData origService = createService("testDeploymentArtifactsOnRI");
1977                 String serviceId = (String) origService.getUniqueId();
1978
1979                 ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
1980                 resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
1981
1982                 Resource rootResource = createRootResource(rootName, resourceOperationTest);
1983                 ArtifactDefinition addArtifactToResource = addArtifactToResource(USER_ID, rootResource.getUniqueId(), "myArtifact");
1984
1985                 // resource1
1986                 ComponentInstance myresourceInstance = buildResourceInstance(rootResource.getUniqueId(), "1", rootName);
1987
1988                 Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true, myresourceInstance, NodeTypeEnum.Resource, false);
1989
1990                 assertTrue("check instance added to service", myinstanceRes.isLeft());
1991
1992                 Either<ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>>, TitanOperationStatus> resourceInstancesOfService = resourceInstanceOperation.getComponentInstancesOfComponent(serviceId, NodeTypeEnum.Service,
1993                                 NodeTypeEnum.Resource);
1994                 assertTrue(resourceInstancesOfService.isLeft());
1995                 List<ComponentInstance> resourceInstanceList = resourceInstancesOfService.left().value().left;
1996                 assertTrue(resourceInstanceList.size() == 1);
1997                 ComponentInstance resourceInstance = resourceInstanceList.get(0);
1998                 assertTrue(resourceInstance.getDeploymentArtifacts().size() == 1);
1999                 Map<String, ArtifactDefinition> artifacts = resourceInstance.getDeploymentArtifacts();
2000                 assertNotNull(artifacts.get(addArtifactToResource.getArtifactLabel()));
2001
2002                 ArtifactDefinition heatEnvArtifact = new ArtifactDefinition(addArtifactToResource);
2003                 heatEnvArtifact.setArtifactType("HEAT_ENV");
2004                 heatEnvArtifact.setArtifactLabel(addArtifactToResource.getArtifactLabel() + "env");
2005                 heatEnvArtifact.setUniqueId(null);
2006
2007                 Either<ArtifactDefinition, StorageOperationStatus> either = artifactOperation.addHeatEnvArtifact(heatEnvArtifact, addArtifactToResource, resourceInstance.getUniqueId(), NodeTypeEnum.ResourceInstance, true);
2008                 assertTrue(either.isLeft());
2009
2010                 resourceInstancesOfService = resourceInstanceOperation.getComponentInstancesOfComponent(serviceId, NodeTypeEnum.Service, NodeTypeEnum.Resource);
2011                 assertTrue(resourceInstancesOfService.isLeft());
2012                 resourceInstanceList = resourceInstancesOfService.left().value().left;
2013                 assertTrue(resourceInstanceList.size() == 1);
2014                 resourceInstance = resourceInstanceList.get(0);
2015                 assertTrue(resourceInstance.getDeploymentArtifacts().size() == 2);
2016                 artifacts = resourceInstance.getDeploymentArtifacts();
2017                 assertNotNull(artifacts.get(addArtifactToResource.getArtifactLabel()));
2018                 assertNotNull(artifacts.get(addArtifactToResource.getArtifactLabel() + "env"));
2019                 ArtifactDefinition heatEnvFromRI = artifacts.get(addArtifactToResource.getArtifactLabel() + "env");
2020                 assertEquals(addArtifactToResource.getUniqueId(), heatEnvFromRI.getGeneratedFromId());
2021
2022                 List<HeatParameterDefinition> heatParameters = artifacts.get(addArtifactToResource.getArtifactLabel()).getListHeatParameters();
2023                 assertNotNull(heatParameters);
2024                 assertTrue(heatParameters.size() == 1);
2025
2026                 List<HeatParameterDefinition> heatEnvParameters = heatEnvFromRI.getListHeatParameters();
2027                 assertNotNull(heatEnvParameters);
2028                 assertTrue(heatEnvParameters.size() == 1);
2029
2030                 resourceOperation.deleteResource(rootResource.getUniqueId());
2031
2032         }
2033
2034         @Test
2035         @Ignore
2036         public void deleteResourceInstanceWithArtifacts() {
2037                 String rootName = "tosca.nodes.test.root";
2038
2039                 ServiceMetadataData origService = createService("deleteResourceInstanceWithArtifacts");
2040                 String serviceId = (String) origService.getUniqueId();
2041
2042                 ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
2043                 resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
2044
2045                 Resource rootResource = createRootResource(rootName, resourceOperationTest);
2046                 ArtifactDefinition addArtifactToResource = addArtifactToResource(USER_ID, rootResource.getUniqueId(), "myArtifact");
2047
2048                 // resource1
2049                 ComponentInstance myresourceInstance = buildResourceInstance(rootResource.getUniqueId(), "1", rootName);
2050
2051                 Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true, myresourceInstance, NodeTypeEnum.Resource, false);
2052
2053                 ArtifactDefinition heatEnvArtifact = new ArtifactDefinition(addArtifactToResource);
2054                 heatEnvArtifact.setArtifactType("HEAT_ENV");
2055                 heatEnvArtifact.setArtifactLabel(addArtifactToResource.getArtifactLabel() + "env");
2056                 heatEnvArtifact.setUniqueId(null);
2057
2058                 assertTrue("check instance added to service", myinstanceRes.isLeft());
2059
2060                 Either<ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>>, TitanOperationStatus> resourceInstancesOfService = resourceInstanceOperation.getComponentInstancesOfComponent(serviceId, NodeTypeEnum.Service,
2061                                 NodeTypeEnum.Resource);
2062                 assertTrue(resourceInstancesOfService.isLeft());
2063                 List<ComponentInstance> resourceInstanceList = resourceInstancesOfService.left().value().left;
2064                 assertTrue(resourceInstanceList.size() == 1);
2065                 ComponentInstance resourceInstance = resourceInstanceList.get(0);
2066
2067                 Either<ArtifactDefinition, StorageOperationStatus> either = artifactOperation.addHeatEnvArtifact(heatEnvArtifact, addArtifactToResource, resourceInstance.getUniqueId(), NodeTypeEnum.ResourceInstance, true);
2068                 assertTrue(either.isLeft());
2069                 ArtifactDefinition heatEnvDefinition = either.left().value();
2070
2071                 // delete resource instance
2072                 Either<ComponentInstance, StorageOperationStatus> deleteResourceInstance = resourceInstanceOperation.deleteComponentInstance(NodeTypeEnum.Service, serviceId, resourceInstance.getUniqueId());
2073                 assertTrue(deleteResourceInstance.isLeft());
2074
2075                 // check heat env deleted
2076                 ArtifactData artifactData = new ArtifactData();
2077                 Either<ArtifactData, TitanOperationStatus> getDeletedArtifact = titanDao.getNode(artifactData.getUniqueIdKey(), heatEnvDefinition.getUniqueId(), ArtifactData.class);
2078                 assertTrue(getDeletedArtifact.isRight());
2079
2080                 // check heat is not deleted
2081                 getDeletedArtifact = titanDao.getNode(artifactData.getUniqueIdKey(), addArtifactToResource.getUniqueId(), ArtifactData.class);
2082                 assertTrue(getDeletedArtifact.isLeft());
2083
2084                 HeatParameterData heatParamData = new HeatParameterData();
2085                 Either<HeatParameterData, TitanOperationStatus> heatParamNode = titanDao.getNode(heatParamData.getUniqueIdKey(), addArtifactToResource.getHeatParameters().get(0).getUniqueId(), HeatParameterData.class);
2086                 assertTrue(heatParamNode.isLeft());
2087
2088                 resourceOperation.deleteResource(rootResource.getUniqueId());
2089
2090         }
2091
2092         @Test
2093         @Ignore
2094         public void getHeatEnvParams() {
2095                 String rootName = "tosca.nodes.test.root";
2096
2097                 ServiceMetadataData origService = createService("getHeatEnvParams");
2098                 String serviceId = (String) origService.getUniqueId();
2099
2100                 ResourceOperationTest resourceOperationTest = new ResourceOperationTest();
2101                 resourceOperationTest.setOperations(titanDao, resourceOperation, propertyOperation);
2102
2103                 Resource rootResource = createRootResource(rootName, resourceOperationTest);
2104                 ArtifactDefinition addArtifactToResource = addArtifactToResource(USER_ID, rootResource.getUniqueId(), "myArtifact");
2105
2106                 // resource1
2107                 ComponentInstance myresourceInstance = buildResourceInstance(rootResource.getUniqueId(), "1", rootName);
2108
2109                 Either<ComponentInstance, TitanOperationStatus> myinstanceRes = resourceInstanceOperation.addComponentInstanceToContainerComponent(serviceId, NodeTypeEnum.Service, "1", true, myresourceInstance, NodeTypeEnum.Resource, false);
2110
2111                 ArtifactDefinition heatEnvArtifact = new ArtifactDefinition(addArtifactToResource);
2112                 heatEnvArtifact.setArtifactType("HEAT_ENV");
2113                 heatEnvArtifact.setArtifactLabel(addArtifactToResource.getArtifactLabel() + "env");
2114                 heatEnvArtifact.setUniqueId(null);
2115
2116                 assertTrue("check instance added to service", myinstanceRes.isLeft());
2117
2118                 Either<ImmutablePair<List<ComponentInstance>, List<RequirementCapabilityRelDef>>, TitanOperationStatus> resourceInstancesOfService = resourceInstanceOperation.getComponentInstancesOfComponent(serviceId, NodeTypeEnum.Service,
2119                                 NodeTypeEnum.Resource);
2120                 assertTrue(resourceInstancesOfService.isLeft());
2121                 List<ComponentInstance> resourceInstanceList = resourceInstancesOfService.left().value().left;
2122                 assertTrue(resourceInstanceList.size() == 1);
2123                 ComponentInstance resourceInstance = resourceInstanceList.get(0);
2124
2125                 Either<ArtifactDefinition, StorageOperationStatus> either = artifactOperation.addHeatEnvArtifact(heatEnvArtifact, addArtifactToResource, resourceInstance.getUniqueId(), NodeTypeEnum.ResourceInstance, true);
2126                 assertTrue(either.isLeft());
2127                 ArtifactDefinition heatEnvDefinition = either.left().value();
2128
2129                 // update value
2130                 String newHeatValue = "123";
2131                 addHeatValueToEnv(heatEnvDefinition.getUniqueId(), addArtifactToResource.getListHeatParameters().get(0), newHeatValue);
2132
2133                 // check values received
2134
2135                 resourceInstancesOfService = resourceInstanceOperation.getComponentInstancesOfComponent(serviceId, NodeTypeEnum.Service, NodeTypeEnum.Resource);
2136                 assertTrue(resourceInstancesOfService.isLeft());
2137                 resourceInstanceList = resourceInstancesOfService.left().value().left;
2138                 assertTrue(resourceInstanceList.size() == 1);
2139                 resourceInstance = resourceInstanceList.get(0);
2140                 assertTrue(resourceInstance.getDeploymentArtifacts().size() == 2);
2141                 Map<String, ArtifactDefinition> artifacts = resourceInstance.getDeploymentArtifacts();
2142                 assertNotNull(artifacts.get(addArtifactToResource.getArtifactLabel()));
2143                 assertNotNull(artifacts.get(addArtifactToResource.getArtifactLabel() + "env"));
2144
2145                 List<HeatParameterDefinition> heatParameters = artifacts.get(addArtifactToResource.getArtifactLabel()).getListHeatParameters();
2146                 assertNotNull(heatParameters);
2147                 assertTrue(heatParameters.size() == 1);
2148                 HeatParameterDefinition heatParameterTemplate = heatParameters.get(0);
2149
2150                 List<HeatParameterDefinition> heatEnvParameters = artifacts.get(addArtifactToResource.getArtifactLabel() + "env").getListHeatParameters();
2151                 assertNotNull(heatEnvParameters);
2152                 assertTrue(heatEnvParameters.size() == 1);
2153                 HeatParameterDefinition heatParameterEnv = heatEnvParameters.get(0);
2154
2155                 assertEquals(heatParameterEnv.getDefaultValue(), heatParameterTemplate.getCurrentValue());
2156                 assertEquals(newHeatValue, heatParameterEnv.getCurrentValue());
2157                 assertFalse(newHeatValue.equals(heatParameterTemplate.getCurrentValue()));
2158
2159                 resourceOperation.deleteResource(rootResource.getUniqueId());
2160
2161         }
2162
2163         public void addHeatValueToEnv(String artifactId, HeatParameterDefinition heatDefinition, String value) {
2164                 HeatParameterValueData heatValueData = new HeatParameterValueData();
2165                 heatValueData.setValue(value);
2166                 heatValueData.setUniqueId(artifactId + "." + heatDefinition.getName());
2167                 Either<HeatParameterValueData, TitanOperationStatus> createValue = titanDao.createNode(heatValueData, HeatParameterValueData.class);
2168                 assertTrue(createValue.isLeft());
2169                 HeatParameterValueData value2 = createValue.left().value();
2170                 HeatParameterData heatParamData = new HeatParameterData(heatDefinition);
2171                 Either<GraphRelation, TitanOperationStatus> createRelation = titanDao.createRelation(value2, heatParamData, GraphEdgeLabels.PROPERTY_IMPL, null);
2172                 assertTrue(createRelation.isLeft());
2173                 Map<String, Object> props = new HashMap<String, Object>();
2174                 props.put(GraphEdgePropertiesDictionary.NAME.getProperty(), heatDefinition.getName());
2175                 Either<GraphRelation, TitanOperationStatus> createRelation2 = titanDao.createRelation(new UniqueIdData(NodeTypeEnum.ArtifactRef, artifactId), value2, GraphEdgeLabels.PARAMETER_VALUE, props);
2176                 assertTrue(createRelation2.isLeft());
2177                 titanDao.commit();
2178
2179         }
2180
2181         public static String normaliseComponentName(String name) {
2182                 String[] split = splitComponentName(name);
2183                 StringBuffer sb = new StringBuffer();
2184                 for (String splitElement : split) {
2185                         sb.append(splitElement);
2186                 }
2187                 return sb.toString();
2188
2189         }
2190
2191         private static String[] splitComponentName(String name) {
2192                 String normalizedName = name.toLowerCase();
2193                 normalizedName = COMPONENT_NAME_DELIMETER_PATTERN.matcher(normalizedName).replaceAll(" ");
2194                 String[] split = normalizedName.split(" ");
2195                 return split;
2196         }
2197
2198         public static String normaliseComponentInstanceName(String name) {
2199                 String[] split = splitComponentInstanceName(name);
2200                 StringBuffer sb = new StringBuffer();
2201                 for (String splitElement : split) {
2202                         sb.append(splitElement);
2203                 }
2204                 return sb.toString();
2205
2206         }
2207
2208         private static String[] splitComponentInstanceName(String name) {
2209                 String normalizedName = name.toLowerCase();
2210                 normalizedName = COMPONENT_INCTANCE_NAME_DELIMETER_PATTERN.matcher(normalizedName).replaceAll(" ");
2211                 String[] split = normalizedName.split(" ");
2212                 return split;
2213         }
2214
2215         private ArtifactDefinition addArtifactToResource(String userId, String resourceId, String artifactName) {
2216                 ArtifactDefinition artifactInfo = new ArtifactDefinition();
2217
2218                 artifactInfo.setArtifactName(artifactName + ".yml");
2219                 artifactInfo.setArtifactType("HEAT");
2220                 artifactInfo.setDescription("hdkfhskdfgh");
2221                 artifactInfo.setArtifactChecksum("UEsDBAoAAAAIAAeLb0bDQz");
2222                 artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
2223
2224                 artifactInfo.setUserIdCreator(userId);
2225                 String fullName = "Jim H";
2226                 artifactInfo.setUpdaterFullName(fullName);
2227                 long time = System.currentTimeMillis();
2228                 artifactInfo.setCreatorFullName(fullName);
2229                 artifactInfo.setCreationDate(time);
2230                 artifactInfo.setLastUpdateDate(time);
2231                 artifactInfo.setUserIdLastUpdater(userId);
2232                 artifactInfo.setArtifactLabel(artifactName);
2233                 artifactInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(resourceId, artifactInfo.getArtifactLabel()));
2234                 artifactInfo.setEsId(artifactInfo.getUniqueId());
2235
2236                 List<HeatParameterDefinition> heatParams = new ArrayList<HeatParameterDefinition>();
2237                 HeatParameterDefinition heatParam = new HeatParameterDefinition();
2238                 heatParam.setCurrentValue("11");
2239                 heatParam.setDefaultValue("22");
2240                 heatParam.setDescription("desc");
2241                 heatParam.setName("myParam");
2242                 heatParam.setType("number");
2243                 heatParams.add(heatParam);
2244                 artifactInfo.setListHeatParameters(heatParams);
2245
2246                 Either<ArtifactDefinition, StorageOperationStatus> artifact = artifactOperation.addArifactToComponent(artifactInfo, resourceId, NodeTypeEnum.Resource, true, true);
2247                 assertTrue(artifact.isLeft());
2248                 return artifact.left().value();
2249         }
2250 }