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