1 package org.openecomp.sdc.be.model.jsontitan.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.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;
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 TitanDao titanDao;
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(titanDao);
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 = titanDao.getVertexById(vfResource0_1.getUniqueId()).left().value();
251 assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue);
253 v = titanDao.getVertexById(vfResource0_2.getUniqueId()).left().value();
254 assertThat(v.getMetadataProperty(GraphPropertyEnum.IS_VSP_ARCHIVED)).isEqualTo(expectedValue);
256 v = titanDao.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, 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);
273 private void assertOnCommit(){
274 final TitanOperationStatus commit = this.titanDao.commit();
275 assertThat(commit).isEqualTo(TitanOperationStatus.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 = titanDao.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, 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
303 assertArchivedOrRestoredProps(action, v);
306 private void assertArchivedProps(String uniqueId) {
308 titanDao.getVertexById(uniqueId).left().value();
309 assertArchivedOrRestoredProps(ArchiveOperation.Action.ARCHIVE, v);
312 private void assertRestoredProps(String uniqueId) {
314 titanDao.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(titanDao);
331 //Create Archive Root
332 this.archiveVertex = GraphTestUtils.createRootArchiveVertex(titanDao);
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(titanDao, propsForHighestVersion());
349 //Connect Service to Catalog Root
350 titanDao.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(titanDao, propsForHighestVersion());
356 this.serviceVertex1_1 = GraphTestUtils.createServiceVertex(titanDao, propsForHighestVersion());
358 titanDao.createEdge(serviceVertex1_0, serviceVertex1_1, EdgeLabelEnum.VERSION, null);
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);
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());
371 //Connect version edges
372 titanDao.createEdge(serviceVertex2_0, serviceVertex3_0, EdgeLabelEnum.VERSION, null);
373 titanDao.createEdge(serviceVertex3_0, serviceVertex3_1, EdgeLabelEnum.VERSION, null);
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);
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());
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);
393 titanDao.createEdge(catalogVertex, serviceVertex0_5, EdgeLabelEnum.CATALOG_ELEMENT, null);
396 private void createResourcesForArchivedVsp(){
397 Map<GraphPropertyEnum, Object> vfPropsNonHighest = propsForNonHighestVersion();
398 Map<GraphPropertyEnum, Object> vfPropsHighest = propsForNonHighestVersion();
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);
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);
409 titanDao.createEdge(vfResource0_1, vfResource0_2, EdgeLabelEnum.VERSION, null);
410 titanDao.createEdge(vfResource0_2, vfResource1_0, EdgeLabelEnum.VERSION, null);
413 private void createMiscServices() {
414 //Create Service for Scenario 1 Tests (1 Service)
415 this.archivedVertex1 = GraphTestUtils.createServiceVertex(titanDao, new HashMap<>());
417 //Connect Service to Catalog Root
418 titanDao.createEdge(archiveVertex, archivedVertex1, EdgeLabelEnum.ARCHIVE_ELEMENT, null);
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());
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);
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);
435 createAndAttachCompositionJson(compositionService);
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();
444 Map<String, ComponentInstanceDataDefinition> instances = new HashMap<>();
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);
452 instance = new ComponentInstanceDataDefinition();
453 instance.setUniqueId(CI_UID_RES2_VL);
454 instance.setComponentUid(compositionResource2.getUniqueId());
455 instances.put(CI_UID_RES2_VL, instance);
457 instance = new ComponentInstanceDataDefinition();
458 instance.setUniqueId(CI_UID_SVC_PROXY);
459 instance.setComponentUid(compositionServiceProxy.getUniqueId());
460 instances.put(CI_UID_SVC_PROXY, instance);
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);
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);
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);