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

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