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

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