private <AH extends AssignmentHolderType> boolean willResetIterationCounter(LensFocusContext<AH> focusContext) throws SchemaException { ObjectDelta<AH> focusDelta = focusContext.getDelta(); if (focusDelta == null) { return false; } if (focusContext.isAdd() || focusContext.isDelete()) { return false; } if (focusDelta.findPropertyDelta(FocusType.F_ITERATION) != null) { // there was a reset already in previous projector runs return false; } // Check for rename PropertyDelta<Object> nameDelta = focusDelta.findPropertyDelta(FocusType.F_NAME); return nameDelta != null; }
public static void assertPropertyAdd(ObjectDelta<?> userDelta, ItemPath propertyPath, Object... expectedValues) { PropertyDelta<Object> propertyDelta = userDelta.findPropertyDelta(propertyPath); assertNotNull("Property delta for "+propertyPath+" not found",propertyDelta); assertAdd(propertyDelta, expectedValues); }
public <O extends ObjectType,T> void assertOldValue(String message, int index, ChangeType expectedChangeType, Class<O> expectedClass, ItemPath propPath, T... expectedValues) { ObjectDeltaOperation<O> deltaOp = getExecutionDelta(index, expectedChangeType, expectedClass); assert deltaOp != null : (message==null?"":message+": ")+"Delta for "+expectedClass+" of type "+expectedChangeType+" was not found in audit trail"; PropertyDelta<Object> propDelta = deltaOp.getObjectDelta().findPropertyDelta(propPath); assert propDelta != null : "No property delta for "+propPath+" in Delta for "+expectedClass+" of type "+expectedChangeType; Collection<PrismPropertyValue<Object>> estimatedOldValues = propDelta.getEstimatedOldValues(); if (expectedValues == null || expectedValues.length == 0) { if (estimatedOldValues == null || estimatedOldValues.isEmpty()) { return; } else { assert false : (message==null?"":message+": ") + "Empty old values in property delta for "+propPath+" in Delta for "+expectedClass+" of type "+expectedChangeType + ", expected " + Arrays.toString(expectedValues); } } assert estimatedOldValues != null && !estimatedOldValues.isEmpty() : "No old values in property delta for "+propPath+" in Delta for "+expectedClass+" of type "+expectedChangeType; PrismAsserts.assertValues((message==null?"":message+": ") +"Wrong old values in property delta for "+propPath+" in Delta for "+expectedClass+" of type "+expectedChangeType, estimatedOldValues, expectedValues); }
public <O extends ObjectType,T> void assertPropertyReplace(String message, int index, ChangeType expectedChangeType, Class<O> expectedClass, ItemPath propPath, T... expectedValues) { ObjectDeltaOperation<O> deltaOp = getExecutionDelta(index, expectedChangeType, expectedClass); assert deltaOp != null : (message==null?"":message+": ")+"Delta for "+expectedClass+" of type "+expectedChangeType+" was not found in audit trail"; PropertyDelta<Object> propDelta = deltaOp.getObjectDelta().findPropertyDelta(propPath); assert propDelta != null : "No property delta for "+propPath+" in Delta for "+expectedClass+" of type "+expectedChangeType; Collection<PrismPropertyValue<Object>> valuesToReplace = propDelta.getValuesToReplace(); assert valuesToReplace != null : "No values to replace in property delta for "+propPath+" in Delta for "+expectedClass+" of type "+expectedChangeType; if (expectedValues == null || expectedValues.length == 0) { if (valuesToReplace.isEmpty()) { return; } else { assert false : (message==null?"":message+": ") + "Empty values to replace in property delta for "+propPath+" in Delta for "+expectedClass+" of type "+expectedChangeType + ", expected " + Arrays.toString(expectedValues); } } PrismAsserts.assertValues((message==null?"":message+": ") +"Wrong values to replace in property delta for "+propPath+" in Delta for "+expectedClass+" of type "+expectedChangeType, valuesToReplace, expectedValues); }
public static void assertPropertyDelete(ObjectDelta<?> userDelta, ItemPath propertyPath, Object... expectedValues) { PropertyDelta propertyDelta = userDelta.findPropertyDelta(propertyPath); assertNotNull("Property delta for "+propertyPath+" not found",propertyDelta); assertSet("delta "+propertyDelta+" for "+propertyPath, "delete", propertyDelta.getValuesToDelete(), expectedValues); }
public static void assertPropertyReplaceSimple(ObjectDelta<?> objectDelta, ItemPath path) { PropertyDelta<Object> propertyDelta = objectDelta.findPropertyDelta(path); assertNotNull("Property delta for "+path+" not found",propertyDelta); assertTrue("No values to replace", propertyDelta.getValuesToReplace() != null && !propertyDelta.getValuesToReplace().isEmpty()); }
public static <T> void assertPropertyReplace(ObjectDelta<?> userDelta, ItemPath path, T... expectedValues) { PropertyDelta<T> propertyDelta = userDelta.findPropertyDelta(path); assertNotNull("Property delta for "+path+" not found",propertyDelta); assertSet("delta " + propertyDelta + " for " + path.last(), "replace", propertyDelta.getValuesToReplace(), expectedValues); }
private <T> void assertAccountItemModify(ObjectDelta<ShadowType> accountDelta, ItemPath itemPath, T[] expectedOldValues, T[] expectedAddValues, T[] expectedDeleteValues, T[] expectedReplaceValues) { PropertyDelta<T> attrDelta = accountDelta.findPropertyDelta(itemPath); assertNotNull("No delta for "+itemPath+" in "+accountDelta, attrDelta); PrismAsserts.assertPropertyDelta(attrDelta, expectedOldValues, expectedAddValues, expectedDeleteValues, expectedReplaceValues); }
private boolean willResetIterationCounter(LensProjectionContext projectionContext) throws SchemaException { ObjectDelta<ShadowType> accountDelta = projectionContext.getDelta(); if (accountDelta == null) { return false; } RefinedObjectClassDefinition oOcDef = projectionContext.getCompositeObjectClassDefinition(); for (RefinedAttributeDefinition identifierDef: oOcDef.getPrimaryIdentifiers()) { ItemPath identifierPath = ItemPath.create(ShadowType.F_ATTRIBUTES, identifierDef.getName()); if (accountDelta.findPropertyDelta(identifierPath) != null) { return true; } } for (RefinedAttributeDefinition identifierDef: oOcDef.getSecondaryIdentifiers()) { ItemPath identifierPath = ItemPath.create(ShadowType.F_ATTRIBUTES, identifierDef.getName()); if (accountDelta.findPropertyDelta(identifierPath) != null) { return true; } } return false; }
/** * Extracts the delta from this projection context and also from all other projection contexts that have * equivalent discriminator. */ public static <F extends ObjectType, T> PropertyDelta<T> findAPrioriDelta(LensContext<F> context, LensProjectionContext projCtx, ItemPath projectionPropertyPath) throws SchemaException { PropertyDelta<T> aPrioriDelta = null; for (LensProjectionContext aProjCtx: findRelatedContexts(context, projCtx)) { ObjectDelta<ShadowType> aProjDelta = aProjCtx.getDelta(); if (aProjDelta != null) { PropertyDelta<T> aPropProjDelta = aProjDelta.findPropertyDelta(projectionPropertyPath); if (aPropProjDelta != null) { if (aPrioriDelta == null) { aPrioriDelta = aPropProjDelta.clone(); } else { aPrioriDelta.merge(aPropProjDelta); } } } } return aPrioriDelta; }
/** * Process values from credential deltas that add/replace values below value container * E.g. $user/credentials/password/value, * $user/credentials/securityQuestions/questionAnswer * $user/credentials/securityQuestions/questionAnswer/questionAnswer * * This implementation is OK for the password, nonce and similar simple cases. It needs to be * overridden for more complex cases. */ protected void processValueDelta(ObjectDelta<UserType> focusDelta) throws PolicyViolationException, SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { PropertyDelta<ProtectedStringType> valueDelta = focusDelta.findPropertyDelta(getCredentialValuePath()); if (valueDelta == null) { LOGGER.trace("Skipping processing {} policies. User delta does not contain value change.", getCredentialHumanReadableName()); return; } processPropertyValueCollection(valueDelta.getValuesToAdd()); processPropertyValueCollection(valueDelta.getValuesToReplace()); }
private void assertConfigurationPropertyChange(ObjectDelta<ResourceType> resourceDelta, String propName) { resourceDelta.checkConsistence(); PropertyDelta propertyDelta = resourceDelta.findPropertyDelta(pathConfigProperties(propName)); assertNotNull("No delta for configuration property "+propName, propertyDelta); // TODO resourceDelta.checkConsistence(); }
private PropertyDelta<PolyString> getCheckedPropertyDeltaFromUnion(ObjectDelta<UserType> userDeltaUnion) { userDeltaUnion.checkConsistence(); assertEquals("Wrong OID", USER_FOO_OID, userDeltaUnion.getOid()); PrismAsserts.assertIsModify(userDeltaUnion); PrismAsserts.assertModifications(userDeltaUnion, 1); PropertyDelta<PolyString> fullNameDeltaUnion = userDeltaUnion.findPropertyDelta(UserType.F_FULL_NAME); assertNotNull("No fullName delta after union", fullNameDeltaUnion); return fullNameDeltaUnion; }
@Test public void testUserCredentialsDiff() throws Exception { System.out.println("===[ testUserCredentialsDiff ]==="); PrismObject<UserType> userBefore = PrismTestUtil.parseObject(USER_BEFORE_FILE); userBefore.checkConsistence(); PrismObject<UserType> userAfter = PrismTestUtil.parseObject(USER_AFTER_FILE); userAfter.checkConsistence(); ObjectDelta<UserType> userDelta = userBefore.diff(userAfter); System.out.println("DELTA:"); System.out.println(userDelta.debugDump()); userBefore.checkConsistence(); userAfter.checkConsistence(); userDelta.checkConsistence(); userDelta.assertDefinitions(); ItemPath path = ItemPath.create(SchemaConstantsGenerated.C_CREDENTIALS, CredentialsType.F_PASSWORD, PasswordType.F_FAILED_LOGINS); PrismAsserts.assertPropertyAdd(userDelta, path, 1); path = ItemPath.create(SchemaConstantsGenerated.C_CREDENTIALS, CredentialsType.F_PASSWORD, PasswordType.F_FAILED_LOGINS); PropertyDelta propertyDelta = userDelta.findPropertyDelta(path); assertNotNull("Property delta for "+path+" not found",propertyDelta); assertEquals(1, propertyDelta.getValuesToAdd().size()); }
@Test public void testPasswordChange() throws Exception { System.out.println("===[ testPasswordChange ]===="); ObjectModificationType objectChange = PrismTestUtil.parseAtomicValue(new File(TEST_DIR, "user-modify-password.xml"), ObjectModificationType.COMPLEX_TYPE); // WHEN ObjectDelta<UserType> objectDelta = DeltaConvertor.createObjectDelta(objectChange, UserType.class, getPrismContext()); // THEN assertNotNull("No object delta", objectDelta); objectDelta.checkConsistence(); assertEquals("Wrong OID", "c0c010c0-d34d-b33f-f00d-111111111111", objectDelta.getOid()); PropertyDelta<ProtectedStringType> protectedStringDelta = objectDelta.findPropertyDelta(CREDENTIALS_PASSWORD_VALUE_PATH); assertNotNull("No protectedString delta", protectedStringDelta); Collection<PrismPropertyValue<ProtectedStringType>> valuesToReplace = protectedStringDelta.getValuesToReplace(); assertEquals("Wrong number of values to replace", 1, valuesToReplace.size()); PrismPropertyValue<ProtectedStringType> protectedStringVal = valuesToReplace.iterator().next(); assertNotNull("Null value in protectedStringDelta", protectedStringVal); PrismObject<UserType> user = PrismTestUtil.parseObject(USER_JACK_FILE); // apply to user objectDelta.applyTo(user); PrismProperty<ProtectedStringType> protectedStringProperty = user.findProperty(CREDENTIALS_PASSWORD_VALUE_PATH); PrismPropertyValue<ProtectedStringType> protectedStringPropertyValue = protectedStringProperty.getValue(); assertTrue("protectedString not equivalent", protectedStringPropertyValue.equals(protectedStringVal, EquivalenceStrategy.REAL_VALUE)); objectDelta.assertDefinitions(); }
@Test public void testModifyGivenName() throws Exception { System.out.println("===[ testModifyGivenName ]===="); ObjectModificationType objectChange = PrismTestUtil.parseAtomicValue(new File(TEST_DIR, "user-modify-givenname.xml"), ObjectModificationType.COMPLEX_TYPE); // WHEN ObjectDelta<UserType> objectDelta = DeltaConvertor.createObjectDelta(objectChange, UserType.class, getPrismContext()); // THEN assertNotNull("No object delta", objectDelta); objectDelta.checkConsistence(); assertEquals("Wrong OID", "c0c010c0-d34d-b33f-f00d-111111111111", objectDelta.getOid()); PropertyDelta<String> givenNameDelta = objectDelta.findPropertyDelta(UserType.F_GIVEN_NAME); assertNotNull("No givenName delta", givenNameDelta); Collection<PrismPropertyValue<String>> valuesToReplace = givenNameDelta.getValuesToReplace(); assertEquals("Wrong number of values to replace", 0, valuesToReplace.size()); PrismObject<UserType> user = PrismTestUtil.parseObject(USER_JACK_FILE); // apply to user objectDelta.applyTo(user); PrismProperty<String> protectedStringProperty = user.findProperty(UserType.F_GIVEN_NAME); assertNull("givenName porperty sneaked in after delta was applied", protectedStringProperty); objectDelta.assertDefinitions(); }
@Test public void testObjectDeltaSummarizeModifyReplace() throws Exception { final String TEST_NAME="testObjectDeltaSummarizeModifyReplace"; displayTestTitle(TEST_NAME); // GIVEN ObjectDelta<UserType> userDelta1 = PrismTestUtil.getPrismContext().deltaFactory().object() .createModificationReplaceProperty(UserType.class, USER_FOO_OID, UserType.F_FULL_NAME, PrismTestUtil.createPolyString("foo")); ObjectDelta<UserType> userDelta2 = PrismTestUtil.getPrismContext().deltaFactory().object() .createModificationReplaceProperty(UserType.class, USER_FOO_OID, UserType.F_FULL_NAME, PrismTestUtil.createPolyString("bar")); // WHEN ObjectDelta<UserType> userDeltaSum = ObjectDeltaCollectionsUtil.summarize(userDelta1, userDelta2); // THEN assertEquals("Wrong OID", USER_FOO_OID, userDeltaSum.getOid()); PrismAsserts.assertIsModify(userDeltaSum); PrismAsserts.assertModifications(userDeltaSum, 1); PropertyDelta<PolyString> fullNameDeltaUnion = userDeltaSum.findPropertyDelta(UserType.F_FULL_NAME); assertNotNull("No fullName delta after summarize", fullNameDeltaUnion); PrismAsserts.assertReplace(fullNameDeltaUnion, PrismTestUtil.createPolyString("bar")); }
@Test public void testObjectDeltaNarrow01() throws Exception { final String TEST_NAME="testObjectDeltaNarrow01"; displayTestTitle(TEST_NAME); // GIVEN ObjectDelta<UserType> userDelta = getPrismContext().deltaFactory().object() .createModificationAddProperty(UserType.class, USER_FOO_OID, UserType.F_ADDITIONAL_NAMES, "blabla", "bubu"); display("userDelta", userDelta); PrismObject<UserType> user = createUserFoo(); display("user", user); // WHEN displayWhen(TEST_NAME); ObjectDelta<UserType> narrowedDelta = userDelta.narrow(user); // THEN displayThen(TEST_NAME); display("Narrowed delta", narrowedDelta); PrismAsserts.assertIsModify(narrowedDelta); PrismAsserts.assertModifications(narrowedDelta, 1); PropertyDelta<String> narrowedAdditionalNamesDelta = narrowedDelta.findPropertyDelta(UserType.F_ADDITIONAL_NAMES); assertNotNull("No additionalNames delta after summarize", narrowedAdditionalNamesDelta); PrismAsserts.assertNoReplace(narrowedAdditionalNamesDelta); PrismAsserts.assertAdd(narrowedAdditionalNamesDelta, "blabla", "bubu"); PrismAsserts.assertNoDelete(narrowedAdditionalNamesDelta); }
@Test public void testObjectDeltaSummarizeModifyAdd() throws Exception { final String TEST_NAME="testObjectDeltaSummarizeModifyAdd"; displayTestTitle(TEST_NAME); // GIVEN ObjectDelta<UserType> userDelta1 = PrismTestUtil.getPrismContext().deltaFactory().object() .createModificationAddProperty(UserType.class, USER_FOO_OID, UserType.F_ADDITIONAL_NAMES, PrismTestUtil.createPolyString("foo")); ObjectDelta<UserType> userDelta2 = PrismTestUtil.getPrismContext().deltaFactory().object() .createModificationAddProperty(UserType.class, USER_FOO_OID, UserType.F_ADDITIONAL_NAMES, PrismTestUtil.createPolyString("bar")); // WHEN ObjectDelta<UserType> userDeltaSum = ObjectDeltaCollectionsUtil.summarize(userDelta1, userDelta2); // THEN assertEquals("Wrong OID", USER_FOO_OID, userDeltaSum.getOid()); PrismAsserts.assertIsModify(userDeltaSum); PrismAsserts.assertModifications(userDeltaSum, 1); PropertyDelta<PolyString> namesDeltaUnion = userDeltaSum.findPropertyDelta(UserType.F_ADDITIONAL_NAMES); assertNotNull("No additionalNames delta after summarize", namesDeltaUnion); PrismAsserts.assertAdd(namesDeltaUnion, PrismTestUtil.createPolyString("foo"), PrismTestUtil.createPolyString("bar")); }
@Test public void testObjectDeltaSummarizeModifyMix() throws Exception { final String TEST_NAME="testObjectDeltaSummarizeModifyMix"; displayTestTitle(TEST_NAME); // GIVEN ObjectDelta<UserType> userDelta1 = PrismTestUtil.getPrismContext().deltaFactory().object() .createModificationAddProperty(UserType.class, USER_FOO_OID, UserType.F_ADDITIONAL_NAMES, PrismTestUtil.createPolyString("baz")); ObjectDelta<UserType> userDelta2 = PrismTestUtil.getPrismContext().deltaFactory().object() .createModificationReplaceProperty(UserType.class, USER_FOO_OID, UserType.F_ADDITIONAL_NAMES, PrismTestUtil.createPolyString("foo")); ObjectDelta<UserType> userDelta3 = PrismTestUtil.getPrismContext().deltaFactory().object() .createModificationAddProperty(UserType.class, USER_FOO_OID, UserType.F_ADDITIONAL_NAMES, PrismTestUtil.createPolyString("bar")); // WHEN ObjectDelta<UserType> userDeltaSum = ObjectDeltaCollectionsUtil.summarize(userDelta1, userDelta2, userDelta3); // THEN assertEquals("Wrong OID", USER_FOO_OID, userDeltaSum.getOid()); PrismAsserts.assertIsModify(userDeltaSum); PrismAsserts.assertModifications(userDeltaSum, 1); PropertyDelta<PolyString> namesDeltaUnion = userDeltaSum.findPropertyDelta(UserType.F_ADDITIONAL_NAMES); assertNotNull("No additionalNames delta after summarize", namesDeltaUnion); PrismAsserts.assertReplace(namesDeltaUnion, PrismTestUtil.createPolyString("foo"), PrismTestUtil.createPolyString("bar")); }