static boolean isEmpty(ObjectDelta delta) { return delta == null || delta.isEmpty(); }
public static void assertEmpty(ObjectDelta<?> objectDelta) { assert objectDelta.isEmpty() : "Expected that object delta "+objectDelta+" is empty, but it is not"; }
public boolean hasAnyDelta() { if (getPrimaryDelta() != null && !getPrimaryDelta().isEmpty()) { return true; } if (secondaryDeltas != null) { for (ObjectDelta<O> waveSecondaryDelta: secondaryDeltas) { if (waveSecondaryDelta != null && !waveSecondaryDelta.isEmpty()) { return true; } } } return false; }
private List<? extends SceneImpl> visualizeDeltas(List<ObjectDelta<? extends ObjectType>> deltas, VisualizationContext context, Task task, OperationResult result) throws SchemaException { List<SceneImpl> rv = new ArrayList<>(deltas.size()); for (ObjectDelta<? extends ObjectType> delta : deltas) { if (!delta.isEmpty()) { final SceneImpl scene = visualizeDelta(delta, null, null, context, task, result); if (!scene.isEmpty()) { rv.add(scene); } } } return rv; }
public boolean hasAnyPrimaryChange() throws SchemaException { if (focusContext != null) { if (!ObjectDelta.isEmpty(focusContext.getPrimaryDelta())) { return true; } } for (LensProjectionContext projCtx : getProjectionContexts()) { if (!ObjectDelta.isEmpty(projCtx.getPrimaryDelta())) { return true; } } return false; }
private boolean shouldBeDeleted(ObjectDelta<ShadowType> accDelta, LensProjectionContext accCtx) { return (accDelta == null || accDelta.isEmpty()) && (accCtx.getSynchronizationPolicyDecision() == SynchronizationPolicyDecision.DELETE || accCtx.getSynchronizationIntent() == SynchronizationIntent.DELETE); }
private <P extends ObjectType> boolean isShadowDeltaSignificant(ObjectDelta<P> delta) { if (delta == null || delta.isEmpty()) { return false; } if (delta.isAdd() || delta.isDelete()) { return true; } Collection<? extends ItemDelta<?,?>> attrDeltas = delta.findItemDeltasSubPath(ShadowType.F_ATTRIBUTES); if (attrDeltas != null && !attrDeltas.isEmpty()) { return true; } return false; }
private <O extends ObjectType> void executeDelta(ObjectDelta<O> objectDelta, ModelExecuteOptions options, Collection<ObjectDeltaOperation<? extends ObjectType>> executedDeltas, Task task, OperationResult result) throws ObjectAlreadyExistsException, ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, PolicyViolationException, SecurityViolationException { result.computeStatus(); if (!result.isSuccess()) { return; } if (objectDelta != null && !objectDelta.isEmpty()) { Collection<ObjectDeltaOperation<? extends ObjectType>> deltaExecutedDeltas = modelController.executeChanges(MiscSchemaUtil.createCollection(objectDelta), options, task, result); executedDeltas.addAll(deltaExecutedDeltas); } }
@Test public void diffRoles() throws Exception { PrismObject<RoleType> role1 = PrismTestUtil.parseObject(ROLE_1); PrismObject<RoleType> role2 = PrismTestUtil.parseObject(ROLE_2); ObjectDelta<RoleType> delta = role1.diff(role2, EquivalenceStrategy.LITERAL_IGNORE_METADATA); assertFalse(delta.isEmpty()); }
protected void assertNoUserSecondaryDelta(LensContext<UserType> context) throws SchemaException { LensFocusContext<UserType> focusContext = context.getFocusContext(); ObjectDelta<UserType> userSecondaryDelta = focusContext.getSecondaryDelta(); if (userSecondaryDelta == null) { return; } assertTrue("User secondary delta is not empty", userSecondaryDelta.isEmpty()); }
private <O extends ObjectType> void serializationRoundTripPrismObject(PrismObject<O> parsedObject) throws Exception { // WHEN String serializedObject = SerializationUtil.toString(parsedObject); // THEN System.out.println("\nSerialized object:"); System.out.println(serializedObject); PrismObject<O> deserializedObject = SerializationUtil.fromString(serializedObject); System.out.println("\nDeserialized object (PrismObject):"); System.out.println(deserializedObject.debugDump()); deserializedObject.revive(getPrismContext()); ObjectDelta<O> diff = parsedObject.diff(deserializedObject); assertTrue("Something changed in serialization of "+parsedObject+" (PrismObject): "+diff, diff.isEmpty()); }
protected void assertNoUserPrimaryDelta(LensContext<UserType> context) { LensFocusContext<UserType> focusContext = context.getFocusContext(); ObjectDelta<UserType> userPrimaryDelta = focusContext.getPrimaryDelta(); if (userPrimaryDelta == null) { return; } assertTrue("User primary delta is not empty", userPrimaryDelta.isEmpty()); }
@Override public void assertsAfterClockworkRun(Task rootTask, List<Task> wfSubtasks, OperationResult result) throws Exception { ModelContext taskModelContext = wfTaskUtil.getModelContext(rootTask, result); assertTrue("Primary focus delta is not empty", taskModelContext.getFocusContext().getPrimaryDelta().isEmpty()); assertNoObject(OrgType.class, ORG_TEST1_OID, rootTask, result); }
@Override public void assertsAfterClockworkRun(Task rootTask, List<Task> wfSubtasks, OperationResult result) throws Exception { ModelContext taskModelContext = wfTaskUtil.getModelContext(rootTask, result); assertTrue("Primary focus delta is not empty", taskModelContext.getFocusContext().getPrimaryDelta().isEmpty()); assertNoObject(OrgType.class, ORG_TEST1_OID, rootTask, result); }
protected void assertUserPrimaryDelta(LensContext<UserType> context) { LensFocusContext<UserType> focusContext = context.getFocusContext(); ObjectDelta<UserType> userPrimaryDelta = focusContext.getPrimaryDelta(); assertNotNull("User primary delta is null", userPrimaryDelta); assertFalse("User primary delta is empty", userPrimaryDelta.isEmpty()); }
protected void assertUserSecondaryDelta(LensContext<UserType> context) throws SchemaException { LensFocusContext<UserType> focusContext = context.getFocusContext(); ObjectDelta<UserType> userSecondaryDelta = focusContext.getSecondaryDelta(); assertNotNull("User secondary delta is null", userSecondaryDelta); assertFalse("User secondary delta is empty", userSecondaryDelta.isEmpty()); }
@Override public void assertsAfterClockworkRun(Task rootTask, List<Task> wfSubtasks, OperationResult result) throws Exception { ModelContext taskModelContext = wfTaskUtil.getModelContext(rootTask, result); IntegrationTestTools.display("model context from the root task", taskModelContext); assertEquals("Wrong # of projection contexts in root task", 1, taskModelContext.getProjectionContexts().size()); assertTrue("There are modifications in primary focus delta", ObjectDelta.isEmpty(taskModelContext.getFocusContext().getPrimaryDelta())); assertTrue("There are modifications left in primary projection delta", ObjectDelta.isEmpty( ((LensProjectionContext) (taskModelContext.getProjectionContexts().iterator().next())) .getPrimaryDelta())); ShadowType account = getObject(ShadowType.class, jackAccountShadowOid).asObjectable(); IntegrationTestTools.display("jack dummy account after first clockwork run", account); assertEquals("Unexpected associations present", 0, account.getAssociation().size()); }
private <F extends ObjectType> ObjectType determineSource(LensFocusContext<F> focusContext) throws SchemaException { ObjectDelta<F> delta = focusContext.getWaveDelta(focusContext.getLensContext().getExecutionWave()); if (delta != null && !delta.isEmpty()) { return focusContext.getObjectNew().asObjectable(); } if (focusContext.getObjectCurrent() != null) { return focusContext.getObjectCurrent().asObjectable(); } return focusContext.getObjectNew().asObjectable(); }
private <O extends ObjectType> void serializationRoundTripObjectType(O parsedObject) throws Exception { // WHEN String serializedObject = SerializationUtil.toString(parsedObject); // THEN O deserializedObject = SerializationUtil.fromString(serializedObject); deserializedObject.asPrismObject().revive(getPrismContext()); System.out.println("Deserialized object (ObjectType):"); System.out.println(deserializedObject.asPrismObject().debugDump()); ObjectDelta<O> diff = parsedObject.asPrismObject().diff((PrismObject) deserializedObject.asPrismObject()); assertTrue("Something changed in serializetion of "+parsedObject+" (ObjectType): "+diff, diff.isEmpty()); }