catalog-model/src/test/java/org/openecomp/sdc/be/model/jsontitan/operations/ArchiveOperationTest.java

   1 package org.openecomp.sdc.be.model.jsontitan.operations;
   2
   3 import fj.data.Either;
   4 import org.junit.Before;
   5 import org.junit.BeforeClass;
   6 import org.junit.Test;
   7 import org.junit.runner.RunWith;
   8 import org.openecomp.sdc.be.dao.api.ActionStatus;
   9 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  10 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  11 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  12 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  13 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  14 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
  15 import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition;
  16 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  17 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  18 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  19 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  20 import org.openecomp.sdc.be.model.ModelTestBase;
  21 import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum;
  22 import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils;
  23 import org.springframework.test.context.ContextConfiguration;
  24 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  25
  26 import javax.annotation.Resource;
  27 import java.util.HashMap;
  28 import java.util.List;
  29 import java.util.Map;
  30
  31 import static org.assertj.core.api.Assertions.assertThat;
  32
  33 /**
  34  * Created by yavivi on 21/03/2018.
  35  */
  36 @RunWith(SpringJUnit4ClassRunner.class)
  37 @ContextConfiguration("classpath:application-context-test.xml")
  38 public class ArchiveOperationTest extends ModelTestBase {
  39
  40     private static final String CI_UID_RES1_CP = "cp_uid";
  41     private static final String CI_UID_RES2_VL = "vl_uid";
  42     private static final String CI_UID_SVC_PROXY = "svc_proxy_uid";
  43
  44     @Resource
  45     private ArchiveOperation archiveOperation;
  46
  47     @Resource
  48     private TitanDao titanDao;
  49
  50     private boolean isInitialized;
  51
  52     private GraphVertex serviceVertex1;
  53     private GraphVertex archivedVertex1;
  54
  55     GraphVertex archiveVertex;
  56     GraphVertex catalogVertex;
  57
  58     private GraphVertex serviceVertex1_0;
  59     private GraphVertex serviceVertex1_1;
  60     private GraphVertex serviceVertex2_0;
  61     private GraphVertex serviceVertex3_0;
  62     private GraphVertex serviceVertex3_1;
  63
  64     private GraphVertex serviceVertex0_1;
  65     private GraphVertex serviceVertex0_2;
  66     private GraphVertex serviceVertex0_3;
  67     private GraphVertex serviceVertex0_4;
  68     private GraphVertex serviceVertex0_5;
  69
  70     //Composition Elements
  71     private GraphVertex compositionService;
  72     private GraphVertex compositionResource1;
  73     private GraphVertex compositionResource2;
  74     private GraphVertex compositionServiceProxy;
  75     private GraphVertex compositionAnotherService;
  76
  77     //For VSP Archive Notification
  78     private GraphVertex vfResource0_1;
  79     private GraphVertex vfResource0_2;
  80     private GraphVertex vfResource1_0;
  81     private String csarUuid = "123456789";;
  82
  83     @BeforeClass
  84     public static void initTest(){
  85         ModelTestBase.init();
  86     }
  87
  88     @Before
  89     public void beforeTest() {
  90         if (!isInitialized) {
  91             GraphTestUtils.clearGraph(titanDao);
  92             initGraphForTest();
  93             isInitialized = true;
  94         }
  95     }
  96
  97     @Test
  98     public void testArchiveComponentSingleVersion(){
  99         String componentId = serviceVertex1.getUniqueId();
 100         Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(componentId);
 101         assertThat(actionStatus.isLeft()).isTrue();
 102         assertArchived(serviceVertex1.getUniqueId());
 103     }
 104
 105     @Test
 106     public void testArchiveComponentFailsWhenInCheckoutSingleVersion(){
 107         checkoutComponent(serviceVertex1);
 108         String componentId = serviceVertex1.getUniqueId();
 109         Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(componentId);
 110         assertThat(actionStatus.isLeft()).isFalse();
 111         assertThat(actionStatus.right().value()).isEqualTo(ActionStatus.INVALID_SERVICE_STATE);
 112     }
 113
 114     @Test
 115     public void testArchiveWithWrongId() {
 116         Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent("fakeComponentId");
 117         assertThat(actionStatus.isLeft()).isFalse();
 118         assertThat(actionStatus.right().value()).isEqualTo(ActionStatus.RESOURCE_NOT_FOUND);
 119     }
 120
 121     @Test
 122     public void testAlreadyArchived() {
 123         Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(archivedVertex1.getUniqueId());
 124         assertThat(actionStatus.isLeft()).isTrue();
 125         assertThat(actionStatus.left().value()).containsExactly(archivedVertex1.getUniqueId());
 126     }
 127
 128     @Test
 129     public void testScenario2_archive_1_0(){
 130         Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex1_0.getUniqueId());
 131         assertThat(actionStatus.isLeft()).isTrue();
 132         assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex1_0.getUniqueId(), serviceVertex1_1.getUniqueId());
 133         assertArchived(serviceVertex1_0.getUniqueId());
 134         assertArchived(serviceVertex1_1.getUniqueId());
 135     }
 136
 137     @Test
 138     public void testScenario2_archive_1_1(){
 139         Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex1_1.getUniqueId());
 140         assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex1_0.getUniqueId(), serviceVertex1_1.getUniqueId());
 141         assertArchived(serviceVertex1_0.getUniqueId());
 142         assertArchived(serviceVertex1_1.getUniqueId());
 143     }
 144
 145     @Test
 146     public void testScenario4_oneLowOneHighestVersion(){
 147         Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex0_2.getUniqueId());
 148         assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex0_2.getUniqueId(), serviceVertex0_1.getUniqueId(), serviceVertex0_3.getUniqueId(), serviceVertex0_4.getUniqueId(), serviceVertex0_5.getUniqueId());
 149         assertArchived(serviceVertex0_1.getUniqueId());
 150         assertArchived(serviceVertex0_2.getUniqueId());
 151         assertArchived(serviceVertex0_3.getUniqueId());
 152         assertArchived(serviceVertex0_4.getUniqueId());
 153         assertArchived(serviceVertex0_5.getUniqueId());
 154
 155         actionStatus = this.archiveOperation.restoreComponent(serviceVertex0_2.getUniqueId());
 156         assertThat(actionStatus.isLeft()).isTrue();
 157         assertThat(actionStatus.left().value()).containsExactlyInAnyOrder(serviceVertex0_2.getUniqueId(), serviceVertex0_1.getUniqueId(), serviceVertex0_3.getUniqueId(), serviceVertex0_4.getUniqueId(), serviceVertex0_5.getUniqueId());
 158     }
 159
 160
 161     /////////////// Continue Here //////////////////
 162     @Test
 163     public void testScenario4_archiveFromNonHighest(){
 164         Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex0_2.getUniqueId());
 165         assertArchived(serviceVertex0_1.getUniqueId());
 166         assertArchived(serviceVertex0_2.getUniqueId());
 167         assertArchived(serviceVertex0_3.getUniqueId());
 168         assertArchived(serviceVertex0_4.getUniqueId());
 169         assertArchived(serviceVertex0_5.getUniqueId());
 170
 171         actionStatus = this.archiveOperation.restoreComponent(serviceVertex0_3.getUniqueId());
 172         assertRestored(serviceVertex0_1.getUniqueId());
 173         assertRestored(serviceVertex0_2.getUniqueId());
 174         assertRestored(serviceVertex0_3.getUniqueId());
 175         assertRestored(serviceVertex0_4.getUniqueId());
 176         assertRestored(serviceVertex0_5.getUniqueId());
 177     }
 178
 179     @Test
 180     public void testArchiveFailsWhenHighestVersionIsInCheckoutState(){
 181         checkoutComponent(serviceVertex0_5);
 182         Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex0_2.getUniqueId());
 183         assertThat(actionStatus.right().value()).isEqualTo(ActionStatus.INVALID_SERVICE_STATE);
 184     }
 185
 186     @Test
 187     public void testScenario3_archive_3_0(){
 188         Either<List<String>, ActionStatus> actionStatus = this.archiveOperation.archiveComponent(serviceVertex3_0.getUniqueId());
 189         assertArchived(serviceVertex3_0.getUniqueId());
 190         assertArchived(serviceVertex3_1.getUniqueId());
 191         assertArchivedProps(serviceVertex2_0.getUniqueId());
 192     }
 193
 194     @Test
 195     public void testArchivedOriginsCalculation(){
 196
 197         //Archive the CP resource
 198         this.archiveOperation.archiveComponent(this.compositionResource1.getUniqueId());
 199         this.archiveOperation.archiveComponent(this.compositionServiceProxy.getUniqueId());
 200
 201         List<String> ciWithArchivedOrigins = this.archiveOperation.setArchivedOriginsFlagInComponentInstances(this.compositionService);
 202
 203         //Validate that method returns the CI of CP
 204         assertThat(ciWithArchivedOrigins).containsExactlyInAnyOrder(CI_UID_RES1_CP, CI_UID_SVC_PROXY);
 205
 206         Map<String, CompositionDataDefinition> compositionsJson = (Map<String, CompositionDataDefinition>) this.compositionService.getJson();
 207
 208         assertThat(compositionsJson).isNotNull();
 209         assertThat(compositionsJson.get(JsonConstantKeysEnum.COMPOSITION.getValue())).isNotNull();
 210
 211         CompositionDataDefinition composition = compositionsJson.get(JsonConstantKeysEnum.COMPOSITION.getValue());
 212
 213         //Get all component instances from composition
 214         Map<String, ComponentInstanceDataDefinition> componentInstances = composition.getComponentInstances();
 215         for (ComponentInstanceDataDefinition ci : componentInstances.values()) {
 216             //Verify that exactly 2 CIs are marked as archived
 217             if (ci.getUniqueId().equals(CI_UID_RES1_CP) || ci.getUniqueId().equals(CI_UID_SVC_PROXY)) {
 218                 assertThat(ci.isOriginArchived()).isTrue();
 219             }
 220         }
 221
 222     }
 223
 224     @Test
 225     public void testNoArchivedOriginsCalculation(){
 226         List<String> ciWithArchivedOrigins = this.archiveOperation.setArchivedOriginsFlagInComponentInstances(this.compositionService);
 227
 228         //Validate that method returns the CI of CP
 229         assertThat(ciWithArchivedOrigins).isEmpty();
 230     }
 231
 232     @Test
 233     public void testOnVspArchivedAndRestored(){
 234         this.archiveOperation.onVspArchived(csarUuid);
 235         //assertOnCommit();
 236
 237         assertOnVspArchived(true);
 238
 239         this.archiveOperation.onVspRestored(csarUuid);
 240         //assertOnCommit();
 241         assertOnVspArchived(false);
 242
 243         //Not Found CSAR UUID
 244         ActionStatus result = this.archiveOperation.onVspRestored("fakeUuid");
 245         //assertOnCommit();
 246         assertThat(result).isEqualTo(ActionStatus.RESOURCE_NOT_FOUND);
 247     }
 248
 249     private void assertOnVspArchived(boolean expectedValue) {
 250         GraphVertex v = titanDao.getVertexById(vfResource0_1.getUniqueId()).left().value();
 251         assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue);
 252
 253         v = titanDao.getVertexById(vfResource0_2.getUniqueId()).left().value();
 254         assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue);
 255
 256         v = titanDao.getVertexById(vfResource1_0.getUniqueId()).left().value();
 257         assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue);
 258     }
 259
 260     /**************************
 261      * Utility Methods
 262      *************************/
 263
 264     private void checkoutComponent(GraphVertex serviceVertex0_5) {
 265         Either<GraphVertex, TitanOperationStatus> vE = titanDao.getVertexById(serviceVertex0_5.getUniqueId());
 266         GraphVertex v = vE.left().value();
 267         v.addMetadataProperty(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 268         v.setJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 269         titanDao.updateVertex(v);
 270         assertOnCommit();
 271     }
 272
 273     private void assertOnCommit(){
 274         final TitanOperationStatus commit = this.titanDao.commit();
 275         assertThat(commit).isEqualTo(TitanOperationStatus.OK);
 276     }
 277
 278     private void assertArchived(String componentUniqueId) {
 279         assertArchivedOrRestored(ArchiveOperation.Action.ARCHIVE, componentUniqueId);
 280     }
 281
 282     private void assertRestored(String componentUniqueId) {
 283         assertArchivedOrRestored(ArchiveOperation.Action.RESTORE, componentUniqueId);
 284     }
 285
 286     private void assertArchivedOrRestored(ArchiveOperation.Action action,  String componentUniqueId) {
 287         GraphVertex v = titanDao.getVertexById(componentUniqueId).left().value();
 288
 289         EdgeLabelEnum requiredEdge = action == ArchiveOperation.Action.ARCHIVE ? EdgeLabelEnum.ARCHIVE_ELEMENT : EdgeLabelEnum.CATALOG_ELEMENT;
 290         EdgeLabelEnum otherEdge = action == ArchiveOperation.Action.ARCHIVE ? EdgeLabelEnum.CATALOG_ELEMENT : EdgeLabelEnum.ARCHIVE_ELEMENT;
 291
 292         GraphVertex parent = null;
 293         Either<GraphVertex, TitanOperationStatus> otherLookup = null;
 294         Boolean isHighest = (Boolean) v.getMetadataProperty(GraphPropertyEnum.IS_HIGHEST_VERSION);
 295         if (isHighest != null && isHighest) {
 296             //Highest version are linked to Archive/Catalog Root
 297             parent = titanDao.getParentVertex(v, requiredEdge, JsonParseFlagEnum.NoParse).left().value();
 298             otherLookup = titanDao.getParentVertex(v, otherEdge, JsonParseFlagEnum.NoParse);
 299             assertThat(otherLookup.isRight()).isTrue();           //Verify that component is not linked to Catalog/Archive Root
 300             assertThat(parent.getUniqueId()).isEqualTo(action == ArchiveOperation.Action.ARCHIVE ? this.archiveVertex.getUniqueId() : this.catalogVertex.getUniqueId()); //Verify that parent is indeed Archive Root
 301         }
 302
 303         assertArchivedOrRestoredProps(action, v);
 304     }
 305
 306     private void assertArchivedProps(String uniqueId) {
 307         GraphVertex v =
 308                 titanDao.getVertexById(uniqueId).left().value();
 309         assertArchivedOrRestoredProps(ArchiveOperation.Action.ARCHIVE, v);
 310     }
 311
 312     private void assertRestoredProps(String uniqueId) {
 313         GraphVertex v =
 314                 titanDao.getVertexById(uniqueId).left().value();
 315         assertArchivedOrRestoredProps(ArchiveOperation.Action.RESTORE, v);
 316     }
 317
 318     private void assertArchivedOrRestoredProps(ArchiveOperation.Action action, GraphVertex v) {
 319         Object isArchived = v.getMetadataProperty(GraphPropertyEnum.IS_ARCHIVED);
 320         Object archiveTime = v.getMetadataProperty(GraphPropertyEnum.ARCHIVE_TIME);
 321         assertThat(isArchived).isNotNull().isEqualTo(action == ArchiveOperation.Action.ARCHIVE ? true : false);
 322         assertThat(archiveTime).isNotNull();
 323     }
 324
 325     /*******************************
 326      * Preperation Methods
 327      *******************************/
 328     private void initGraphForTest() {
 329         //Create Catalog Root
 330         this.catalogVertex = GraphTestUtils.createRootCatalogVertex(titanDao);
 331         //Create Archive Root
 332         this.archiveVertex = GraphTestUtils.createRootArchiveVertex(titanDao);
 333
 334         createScenario1_SingleVersionNode();
 335         createScenario2_TwoHighestVersions();
 336         createScenario3_TwoHighestVersionsOneLowest();
 337         createMiscServices();
 338         createServiceCompositionForCalculatingArchivedOrigins();
 339         createScenario4_1Highest4LowestVersions();
 340         createResourcesForArchivedVsp();
 341
 342         assertOnCommit();
 343     }
 344
 345     private void createScenario1_SingleVersionNode() {
 346         //Create Service for Scenario 1 Tests (1 Service)
 347         this.serviceVertex1 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion());
 348
 349         //Connect Service to Catalog Root
 350         titanDao.createEdge(catalogVertex, serviceVertex1, EdgeLabelEnum.CATALOG_ELEMENT, null);
 351     }
 352
 353     private void createScenario2_TwoHighestVersions() {
 354         //Create Service for Scenario 2 Tests (1 Service)
 355         this.serviceVertex1_0 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion());
 356         this.serviceVertex1_1 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion());
 357
 358         titanDao.createEdge(serviceVertex1_0, serviceVertex1_1, EdgeLabelEnum.VERSION, null);
 359
 360         //Connect 1.0 and 1.1 to Catalog Root
 361         titanDao.createEdge(catalogVertex, serviceVertex1_0, EdgeLabelEnum.CATALOG_ELEMENT, null);
 362         titanDao.createEdge(catalogVertex, serviceVertex1_1, EdgeLabelEnum.CATALOG_ELEMENT, null);
 363     }
 364
 365     private void createScenario3_TwoHighestVersionsOneLowest() {
 366         //Create Service for Scenario 1 Tests (1 Service)
 367         this.serviceVertex2_0 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion()); //NonHighestVersion
 368         this.serviceVertex3_0 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion());
 369         this.serviceVertex3_1 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion());
 370
 371         //Connect version edges
 372         titanDao.createEdge(serviceVertex2_0, serviceVertex3_0, EdgeLabelEnum.VERSION, null);
 373         titanDao.createEdge(serviceVertex3_0, serviceVertex3_1, EdgeLabelEnum.VERSION, null);
 374
 375         //Connect 3.0 and 3.1 to Catalog Root
 376         titanDao.createEdge(catalogVertex, serviceVertex3_0, EdgeLabelEnum.CATALOG_ELEMENT, null);
 377         titanDao.createEdge(catalogVertex, serviceVertex3_1, EdgeLabelEnum.CATALOG_ELEMENT, null);
 378     }
 379
 380     private void createScenario4_1Highest4LowestVersions() {
 381         //2 Lowest version only
 382         this.serviceVertex0_1 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion());
 383         this.serviceVertex0_2 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion());
 384         this.serviceVertex0_3 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion());
 385         this.serviceVertex0_4 = GraphTestUtils.createServiceVertex(titanDao, propsForNonHighestVersion());
 386         this.serviceVertex0_5 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion());
 387
 388         titanDao.createEdge(serviceVertex0_1, serviceVertex0_2, EdgeLabelEnum.VERSION, null);
 389         titanDao.createEdge(serviceVertex0_2, serviceVertex0_3, EdgeLabelEnum.VERSION, null);
 390         titanDao.createEdge(serviceVertex0_3, serviceVertex0_4, EdgeLabelEnum.VERSION, null);
 391         titanDao.createEdge(serviceVertex0_4, serviceVertex0_5, EdgeLabelEnum.VERSION, null);
 392
 393         titanDao.createEdge(catalogVertex, serviceVertex0_5, EdgeLabelEnum.CATALOG_ELEMENT, null);
 394     }
 395
 396     private void createResourcesForArchivedVsp(){
 397         Map<GraphPropertyEnum, Object> vfPropsNonHighest = propsForNonHighestVersion();
 398         Map<GraphPropertyEnum, Object> vfPropsHighest = propsForNonHighestVersion();
 399
 400         vfPropsNonHighest.put(GraphPropertyEnum.CSAR_UUID, csarUuid);
 401         vfPropsNonHighest.put(GraphPropertyEnum.IS_VSP_ARCHIVED, false);
 402         vfPropsHighest.put(GraphPropertyEnum.CSAR_UUID, csarUuid);
 403         vfPropsHighest.put(GraphPropertyEnum.IS_VSP_ARCHIVED, false);
 404
 405         this.vfResource0_1 = GraphTestUtils.createResourceVertex(titanDao, vfPropsNonHighest, ResourceTypeEnum.VF);
 406         this.vfResource0_2 = GraphTestUtils.createResourceVertex(titanDao, vfPropsNonHighest, ResourceTypeEnum.VF);
 407         this.vfResource1_0 = GraphTestUtils.createResourceVertex(titanDao, vfPropsHighest, ResourceTypeEnum.VF);
 408
 409         titanDao.createEdge(vfResource0_1, vfResource0_2, EdgeLabelEnum.VERSION, null);
 410         titanDao.createEdge(vfResource0_2, vfResource1_0, EdgeLabelEnum.VERSION, null);
 411     }
 412
 413     private void createMiscServices() {
 414         //Create Service for Scenario 1 Tests (1 Service)
 415         this.archivedVertex1 = GraphTestUtils.createServiceVertex(titanDao, new HashMap<>());
 416
 417         //Connect Service to Catalog Root
 418         titanDao.createEdge(archiveVertex, archivedVertex1, EdgeLabelEnum.ARCHIVE_ELEMENT, null);
 419     }
 420
 421     private void createServiceCompositionForCalculatingArchivedOrigins(){
 422         //Service that point to another service in composition
 423         this.compositionService = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion());
 424         this.compositionAnotherService = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion());
 425
 426         this.compositionResource1 = GraphTestUtils.createResourceVertex(titanDao, propsForHighestVersion(), ResourceTypeEnum.CP);
 427         this.compositionResource2 = GraphTestUtils.createResourceVertex(titanDao, propsForHighestVersion(), ResourceTypeEnum.VL);
 428         this.compositionServiceProxy = GraphTestUtils.createResourceVertex(titanDao, propsForHighestVersion(), ResourceTypeEnum.ServiceProxy);
 429
 430         titanDao.createEdge(compositionService, compositionResource1, EdgeLabelEnum.INSTANCE_OF, null);
 431         titanDao.createEdge(compositionService, compositionResource2, EdgeLabelEnum.INSTANCE_OF, null);
 432         titanDao.createEdge(compositionService, compositionServiceProxy, EdgeLabelEnum.INSTANCE_OF, null);
 433         titanDao.createEdge(compositionService, compositionAnotherService, EdgeLabelEnum.PROXY_OF, null);
 434
 435         createAndAttachCompositionJson(compositionService);
 436     }
 437
 438     private void createAndAttachCompositionJson(GraphVertex compositionService) {
 439         //Full composition json
 440         Map<String, CompositionDataDefinition> compositions = new HashMap<>();
 441         //Single composition data
 442         CompositionDataDefinition composition = new CompositionDataDefinition();
 443         //Instances Map
 444         Map<String, ComponentInstanceDataDefinition> instances = new HashMap<>();
 445
 446         //Prepare Instances Map
 447         ComponentInstanceDataDefinition instance = new ComponentInstanceDataDefinition();
 448         instance.setUniqueId(CI_UID_RES1_CP);
 449         instance.setComponentUid(compositionResource1.getUniqueId());
 450         instances.put(CI_UID_RES1_CP, instance);
 451
 452         instance = new ComponentInstanceDataDefinition();
 453         instance.setUniqueId(CI_UID_RES2_VL);
 454         instance.setComponentUid(compositionResource2.getUniqueId());
 455         instances.put(CI_UID_RES2_VL, instance);
 456
 457         instance = new ComponentInstanceDataDefinition();
 458         instance.setUniqueId(CI_UID_SVC_PROXY);
 459         instance.setComponentUid(compositionServiceProxy.getUniqueId());
 460         instances.put(CI_UID_SVC_PROXY, instance);
 461
 462         //Add Instances to Composition
 463         composition.setComponentInstances(instances);
 464         //Add to full composition
 465         compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), composition);
 466         //Add Full Json to vertex
 467         compositionService.setJson(compositions);
 468         //System.out.println(JsonParserUtils.toJson(compositions));
 469         titanDao.updateVertex(compositionService);
 470     }
 471
 472     private Map<GraphPropertyEnum, Object> propsForHighestVersion(){
 473         Map<GraphPropertyEnum, Object> props = new HashMap();
 474         props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
 475         props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 476         return props;
 477     }
 478
 479     private Map<GraphPropertyEnum, Object> propsForNonHighestVersion(){
 480         Map<GraphPropertyEnum, Object> props = new HashMap();
 481         props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, false);
 482         props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 483         return props;
 484     }
 485
 486 }