1 package org.openecomp.sdc.be.model.jsonjanusgraph.operations;
4 import org.junit.Before;
5 import org.junit.BeforeClass;
7 import org.junit.runner.RunWith;
8 import org.openecomp.sdc.be.dao.api.ActionStatus;
9 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
10 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
11 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
12 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
13 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
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.jsonjanusgraph.enums.JsonConstantKeysEnum;
22 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.GraphTestUtils;
23 import org.springframework.test.context.ContextConfiguration;
24 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
26 import javax.annotation.Resource;
27 import java.util.HashMap;
28 import java.util.List;
31 import static org.assertj.core.api.Assertions.assertThat;
34 * Created by yavivi on 21/03/2018.
36 @RunWith(SpringJUnit4ClassRunner.class)
37 @ContextConfiguration(value = {"classpath:application-context-test.xml", "classpath:healing-context-test.xml"})
38 public class ArchiveOperationTest extends ModelTestBase {
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";
45 private ArchiveOperation archiveOperation;
48 private JanusGraphDao janusGraphDao;
50 private boolean isInitialized;
52 private GraphVertex serviceVertex1;
53 private GraphVertex archivedVertex1;
55 GraphVertex archiveVertex;
56 GraphVertex catalogVertex;
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;
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;
70 //Composition Elements
71 private GraphVertex compositionService;
72 private GraphVertex compositionResource1;
73 private GraphVertex compositionResource2;
74 private GraphVertex compositionServiceProxy;
75 private GraphVertex compositionAnotherService;
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";;
84 public static void initTest(){
89 public void beforeTest() {
91 GraphTestUtils.clearGraph(janusGraphDao);
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());
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);
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);
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());
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());
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());
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());
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());
161 /////////////// Continue Here //////////////////
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());
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());
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);
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());
195 public void testArchivedOriginsCalculation(){
197 //Archive the CP resource
198 this.archiveOperation.archiveComponent(this.compositionResource1.getUniqueId());
199 this.archiveOperation.archiveComponent(this.compositionServiceProxy.getUniqueId());
201 List<String> ciWithArchivedOrigins = this.archiveOperation.setArchivedOriginsFlagInComponentInstances(this.compositionService);
203 //Validate that method returns the CI of CP
204 assertThat(ciWithArchivedOrigins).containsExactlyInAnyOrder(CI_UID_RES1_CP, CI_UID_SVC_PROXY);
206 Map<String, CompositionDataDefinition> compositionsJson = (Map<String, CompositionDataDefinition>) this.compositionService.getJson();
208 assertThat(compositionsJson).isNotNull();
209 assertThat(compositionsJson.get(JsonConstantKeysEnum.COMPOSITION.getValue())).isNotNull();
211 CompositionDataDefinition composition = compositionsJson.get(JsonConstantKeysEnum.COMPOSITION.getValue());
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();
225 public void testNoArchivedOriginsCalculation(){
226 List<String> ciWithArchivedOrigins = this.archiveOperation.setArchivedOriginsFlagInComponentInstances(this.compositionService);
228 //Validate that method returns the CI of CP
229 assertThat(ciWithArchivedOrigins).isEmpty();
233 public void testOnVspArchivedAndRestored(){
234 this.archiveOperation.onVspArchived(csarUuid);
237 assertOnVspArchived(true);
239 this.archiveOperation.onVspRestored(csarUuid);
241 assertOnVspArchived(false);
243 //Not Found CSAR UUID
244 ActionStatus result = this.archiveOperation.onVspRestored("fakeUuid");
246 assertThat(result).isEqualTo(ActionStatus.RESOURCE_NOT_FOUND);
249 private void assertOnVspArchived(boolean expectedValue) {
250 GraphVertex v = janusGraphDao.getVertexById(vfResource0_1.getUniqueId()).left().value();
251 assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue);
253 v = janusGraphDao.getVertexById(vfResource0_2.getUniqueId()).left().value();
254 assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue);
256 v = janusGraphDao.getVertexById(vfResource1_0.getUniqueId()).left().value();
257 assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue);
260 /**************************
262 *************************/
264 private void checkoutComponent(GraphVertex serviceVertex0_5) {
265 Either<GraphVertex, JanusGraphOperationStatus> vE = janusGraphDao.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 janusGraphDao.updateVertex(v);
273 private void assertOnCommit(){
274 final JanusGraphOperationStatus commit = this.janusGraphDao.commit();
275 assertThat(commit).isEqualTo(JanusGraphOperationStatus.OK);
278 private void assertArchived(String componentUniqueId) {
279 assertArchivedOrRestored(ArchiveOperation.Action.ARCHIVE, componentUniqueId);
282 private void assertRestored(String componentUniqueId) {
283 assertArchivedOrRestored(ArchiveOperation.Action.RESTORE, componentUniqueId);
286 private void assertArchivedOrRestored(ArchiveOperation.Action action, String componentUniqueId) {
287 GraphVertex v = janusGraphDao.getVertexById(componentUniqueId).left().value();
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;
292 GraphVertex parent = null;
293 Either<GraphVertex, JanusGraphOperationStatus> 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 = janusGraphDao.getParentVertex(v, requiredEdge, JsonParseFlagEnum.NoParse).left().value();
298 otherLookup = janusGraphDao.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
303 assertArchivedOrRestoredProps(action, v);
306 private void assertArchivedProps(String uniqueId) {
308 janusGraphDao.getVertexById(uniqueId).left().value();
309 assertArchivedOrRestoredProps(ArchiveOperation.Action.ARCHIVE, v);
312 private void assertRestoredProps(String uniqueId) {
314 janusGraphDao.getVertexById(uniqueId).left().value();
315 assertArchivedOrRestoredProps(ArchiveOperation.Action.RESTORE, v);
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();
325 /*******************************
326 * Preperation Methods
327 *******************************/
328 private void initGraphForTest() {
329 //Create Catalog Root
330 this.catalogVertex = GraphTestUtils.createRootCatalogVertex(janusGraphDao);
331 //Create Archive Root
332 this.archiveVertex = GraphTestUtils.createRootArchiveVertex(janusGraphDao);
334 createScenario1_SingleVersionNode();
335 createScenario2_TwoHighestVersions();
336 createScenario3_TwoHighestVersionsOneLowest();
337 createMiscServices();
338 createServiceCompositionForCalculatingArchivedOrigins();
339 createScenario4_1Highest4LowestVersions();
340 createResourcesForArchivedVsp();
345 private void createScenario1_SingleVersionNode() {
346 //Create Service for Scenario 1 Tests (1 Service)
347 this.serviceVertex1 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion());
349 //Connect Service to Catalog Root
350 janusGraphDao.createEdge(catalogVertex, serviceVertex1, EdgeLabelEnum.CATALOG_ELEMENT, null);
353 private void createScenario2_TwoHighestVersions() {
354 //Create Service for Scenario 2 Tests (1 Service)
355 this.serviceVertex1_0 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion());
356 this.serviceVertex1_1 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion());
358 janusGraphDao.createEdge(serviceVertex1_0, serviceVertex1_1, EdgeLabelEnum.VERSION, null);
360 //Connect 1.0 and 1.1 to Catalog Root
362 .createEdge(catalogVertex, serviceVertex1_0, EdgeLabelEnum.CATALOG_ELEMENT, null);
364 .createEdge(catalogVertex, serviceVertex1_1, EdgeLabelEnum.CATALOG_ELEMENT, null);
367 private void createScenario3_TwoHighestVersionsOneLowest() {
368 //Create Service for Scenario 1 Tests (1 Service)
369 this.serviceVertex2_0 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForNonHighestVersion()); //NonHighestVersion
370 this.serviceVertex3_0 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion());
371 this.serviceVertex3_1 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion());
373 //Connect version edges
374 janusGraphDao.createEdge(serviceVertex2_0, serviceVertex3_0, EdgeLabelEnum.VERSION, null);
375 janusGraphDao.createEdge(serviceVertex3_0, serviceVertex3_1, EdgeLabelEnum.VERSION, null);
377 //Connect 3.0 and 3.1 to Catalog Root
379 .createEdge(catalogVertex, serviceVertex3_0, EdgeLabelEnum.CATALOG_ELEMENT, null);
381 .createEdge(catalogVertex, serviceVertex3_1, EdgeLabelEnum.CATALOG_ELEMENT, null);
384 private void createScenario4_1Highest4LowestVersions() {
385 //2 Lowest version only
386 this.serviceVertex0_1 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForNonHighestVersion());
387 this.serviceVertex0_2 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForNonHighestVersion());
388 this.serviceVertex0_3 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForNonHighestVersion());
389 this.serviceVertex0_4 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForNonHighestVersion());
390 this.serviceVertex0_5 = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion());
392 janusGraphDao.createEdge(serviceVertex0_1, serviceVertex0_2, EdgeLabelEnum.VERSION, null);
393 janusGraphDao.createEdge(serviceVertex0_2, serviceVertex0_3, EdgeLabelEnum.VERSION, null);
394 janusGraphDao.createEdge(serviceVertex0_3, serviceVertex0_4, EdgeLabelEnum.VERSION, null);
395 janusGraphDao.createEdge(serviceVertex0_4, serviceVertex0_5, EdgeLabelEnum.VERSION, null);
398 .createEdge(catalogVertex, serviceVertex0_5, EdgeLabelEnum.CATALOG_ELEMENT, null);
401 private void createResourcesForArchivedVsp(){
402 Map<GraphPropertyEnum, Object> vfPropsNonHighest = propsForNonHighestVersion();
403 Map<GraphPropertyEnum, Object> vfPropsHighest = propsForNonHighestVersion();
405 vfPropsNonHighest.put(GraphPropertyEnum.CSAR_UUID, csarUuid);
406 vfPropsNonHighest.put(GraphPropertyEnum.IS_VSP_ARCHIVED, false);
407 vfPropsHighest.put(GraphPropertyEnum.CSAR_UUID, csarUuid);
408 vfPropsHighest.put(GraphPropertyEnum.IS_VSP_ARCHIVED, false);
410 this.vfResource0_1 = GraphTestUtils.createResourceVertex(janusGraphDao, vfPropsNonHighest, ResourceTypeEnum.VF);
411 this.vfResource0_2 = GraphTestUtils.createResourceVertex(janusGraphDao, vfPropsNonHighest, ResourceTypeEnum.VF);
412 this.vfResource1_0 = GraphTestUtils.createResourceVertex(janusGraphDao, vfPropsHighest, ResourceTypeEnum.VF);
414 janusGraphDao.createEdge(vfResource0_1, vfResource0_2, EdgeLabelEnum.VERSION, null);
415 janusGraphDao.createEdge(vfResource0_2, vfResource1_0, EdgeLabelEnum.VERSION, null);
418 private void createMiscServices() {
419 //Create Service for Scenario 1 Tests (1 Service)
420 this.archivedVertex1 = GraphTestUtils.createServiceVertex(janusGraphDao, new HashMap<>());
422 //Connect Service to Catalog Root
423 janusGraphDao.createEdge(archiveVertex, archivedVertex1, EdgeLabelEnum.ARCHIVE_ELEMENT, null);
426 private void createServiceCompositionForCalculatingArchivedOrigins(){
427 //Service that point to another service in composition
428 this.compositionService = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion());
429 this.compositionAnotherService = GraphTestUtils.createServiceVertex(janusGraphDao, propsForHighestVersion());
431 this.compositionResource1 = GraphTestUtils.createResourceVertex(janusGraphDao, propsForHighestVersion(), ResourceTypeEnum.CP);
432 this.compositionResource2 = GraphTestUtils.createResourceVertex(janusGraphDao, propsForHighestVersion(), ResourceTypeEnum.VL);
433 this.compositionServiceProxy = GraphTestUtils.createResourceVertex(janusGraphDao, propsForHighestVersion(), ResourceTypeEnum.ServiceProxy);
436 .createEdge(compositionService, compositionResource1, EdgeLabelEnum.INSTANCE_OF, null);
438 .createEdge(compositionService, compositionResource2, EdgeLabelEnum.INSTANCE_OF, null);
440 .createEdge(compositionService, compositionServiceProxy, EdgeLabelEnum.INSTANCE_OF, null);
442 .createEdge(compositionService, compositionAnotherService, EdgeLabelEnum.PROXY_OF, null);
444 createAndAttachCompositionJson(compositionService);
447 private void createAndAttachCompositionJson(GraphVertex compositionService) {
448 //Full composition json
449 Map<String, CompositionDataDefinition> compositions = new HashMap<>();
450 //Single composition data
451 CompositionDataDefinition composition = new CompositionDataDefinition();
453 Map<String, ComponentInstanceDataDefinition> instances = new HashMap<>();
455 //Prepare Instances Map
456 ComponentInstanceDataDefinition instance = new ComponentInstanceDataDefinition();
457 instance.setUniqueId(CI_UID_RES1_CP);
458 instance.setComponentUid(compositionResource1.getUniqueId());
459 instances.put(CI_UID_RES1_CP, instance);
461 instance = new ComponentInstanceDataDefinition();
462 instance.setUniqueId(CI_UID_RES2_VL);
463 instance.setComponentUid(compositionResource2.getUniqueId());
464 instances.put(CI_UID_RES2_VL, instance);
466 instance = new ComponentInstanceDataDefinition();
467 instance.setUniqueId(CI_UID_SVC_PROXY);
468 instance.setComponentUid(compositionServiceProxy.getUniqueId());
469 instances.put(CI_UID_SVC_PROXY, instance);
471 //Add Instances to Composition
472 composition.setComponentInstances(instances);
473 //Add to full composition
474 compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), composition);
475 //Add Full Json to vertex
476 compositionService.setJson(compositions);
477 //System.out.println(JsonParserUtils.toJson(compositions));
478 janusGraphDao.updateVertex(compositionService);
481 private Map<GraphPropertyEnum, Object> propsForHighestVersion(){
482 Map<GraphPropertyEnum, Object> props = new HashMap();
483 props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, true);
484 props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
488 private Map<GraphPropertyEnum, Object> propsForNonHighestVersion(){
489 Map<GraphPropertyEnum, Object> props = new HashMap();
490 props.put(GraphPropertyEnum.IS_HIGHEST_VERSION, false);
491 props.put(GraphPropertyEnum.STATE, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);