protected void assertSituation(PrismObject<ShadowType> shadow, SynchronizationSituationType expectedSituation) { if (expectedSituation == null) { PrismAsserts.assertNoItem(shadow, ShadowType.F_SYNCHRONIZATION_SITUATION); } else { PrismAsserts.assertPropertyValue(shadow, ShadowType.F_SYNCHRONIZATION_SITUATION, expectedSituation); } }
public static <T> void assertPropertyValues(String message, Collection<T> expected, Collection<PrismPropertyValue<T>> results) { assertEquals(message+" - unexpected number of results", expected.size(), results.size()); Set<Object> values = new HashSet<>(); for (PrismPropertyValue<T> result : results) { values.add(result.getValue()); } assertEquals(message, expected, values); }
protected void assertAuthorizationActions(String message, Collection<Authorization> autzs, String... expectedActions) { Collection<String> actualActions = autzs.stream() .map(a -> a.getAction()) .flatMap(List::stream) .collect(Collectors.toList()); PrismAsserts.assertEqualsCollectionUnordered(message, actualActions, expectedActions); }
public static <O extends Objectable> void assertEquivalent(String message, File expectedFile, PrismObject<O> actual) throws SchemaException, IOException { PrismObject<O> expected = toPrism(expectedFile); assertEquivalent(message, expected, actual); }
public static void assertDefinition(ItemDefinition definition, QName itemName, QName type, int minOccurs, int maxOccurs) { assertNotNull("No definition for "+itemName, definition); assertEquals("Wrong definition type for "+itemName, type, definition.getTypeName()); assertEquals("Wrong definition minOccurs for "+itemName, minOccurs, definition.getMinOccurs()); assertEquals("Wrong definition maxOccurs for "+itemName, maxOccurs, definition.getMaxOccurs()); }
protected void assertUserProperty(PrismObject<UserType> user, QName propertyName, Object... expectedPropValues) { PrismProperty<Object> property = user.findProperty(ItemName.fromQName(propertyName)); assert property != null : "No property "+propertyName+" in "+user; PrismAsserts.assertPropertyValue(property, expectedPropValues); }
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; }
protected <T> void assertAttribute(PrismObject<ResourceType> resource, ShadowType shadow, MatchingRule<T> matchingRule, QName attrQname, T... expectedValues) throws SchemaException { List<T> actualValues = ShadowUtil.getAttributeValues(shadow, attrQname); PrismAsserts.assertSets("attribute "+attrQname+" in " + shadow, matchingRule, actualValues, expectedValues); }
@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")); }
public DisplayTypeAsserter<RA> assertPluralLabel(String expectedOrig) { PrismAsserts.assertEqualsPolyString("Wrong pluralLabel in "+desc(), expectedOrig, displayType.getPluralLabel()); return this; }
public static <O extends Objectable> void assertEquivalent(File expectedFile, PrismObject<O> actual) throws SchemaException, IOException { assertEquivalent("Object "+actual+" not equivalent to that from file "+expectedFile,expectedFile,actual); }
public static void assertContainerDefinition(PrismContainer container, String contName, QName xsdType, int minOccurs, int maxOccurs) { QName qName = new QName(NS_FOO, contName); PrismAsserts.assertDefinition(container.getDefinition(), qName, xsdType, minOccurs, maxOccurs); }
@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); }
public static void assertPropertyDefinition(PrismContainer<?> container, String propName, QName xsdType, int minOccurs, int maxOccurs) { QName propQName = new QName(NS_FOO, propName); PrismAsserts.assertPropertyDefinition(container, propQName, xsdType, minOccurs, maxOccurs); }
public static void assertRefFilter(ObjectFilter objectFilter, QName expectedFilterDef, QName expectedTypeName, ItemPath path) { assertTrue("Wrong filter class: " + objectFilter.getClass(), objectFilter instanceof RefFilter); RefFilter filter = (RefFilter) objectFilter; assertEquals("Wrong filter definition element name", expectedFilterDef, filter.getDefinition().getName()); assertEquals("Wrong filter definition type", expectedTypeName, filter.getDefinition().getTypeName()); assertPathEquivalent("Wrong filter path", path, filter.getFullPath()); }
public static <T> void assertPropertyValue(PrismContainer<?> container, ItemPath propPath, T... realPropValues) { PrismContainerValue<?> containerValue = container.getValue(); assertSame("Wrong parent for value of container "+container, container, containerValue.getParent()); assertPropertyValue(containerValue, propPath, realPropValues); }
public ShadowAsserter<RA> assertNoLegacyConsistency() { PrismAsserts.assertNoItem(getObject(), ShadowType.F_RESULT); PrismAsserts.assertNoItem(getObject(), ShadowType.F_ATTEMPT_NUMBER); PrismAsserts.assertNoItem(getObject(), ShadowType.F_FAILED_OPERATION_TYPE); PrismAsserts.assertNoItem(getObject(), ShadowType.F_OBJECT_CHANGE); return this; }
private void assertAccountDefinition(PrismObjectDefinition<AccountType> accountDefinition) { assertEquals("Wrong compile-time class in account definition", AccountType.class, accountDefinition.getCompileTimeClass()); PrismAsserts.assertPropertyDefinition(accountDefinition, ACCOUNT_NAME_QNAME, PolyStringType.COMPLEX_TYPE, 0, 1); PrismAsserts.assertPropertyDefinition(accountDefinition, ACCOUNT_DESCRIPTION_QNAME, DOMUtil.XSD_STRING, 0, 1); assertFalse("Account definition is marked as runtime", accountDefinition.isRuntimeSchema()); PrismContainerDefinition attributesContainer = accountDefinition.findContainerDefinition(ACCOUNT_ATTRIBUTES_QNAME); PrismAsserts.assertDefinition(attributesContainer, ACCOUNT_ATTRIBUTES_QNAME, ATTRIBUTES_TYPE_QNAME, 0, 1); assertTrue("Attributes is NOT runtime", attributesContainer.isRuntimeSchema()); }
@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")); }
public static void assertDefinitionTypeLoose(ItemDefinition definition, QName itemName, QName type, int minOccurs, int maxOccurs) { assertNotNull("No definition for "+itemName, definition); assertTrue("Wrong definition type for "+itemName+": expected: " + type + ", real: " + definition.getTypeName(), QNameUtil.match(type, definition.getTypeName())); assertEquals("Wrong definition minOccurs for "+itemName, minOccurs, definition.getMinOccurs()); assertEquals("Wrong definition maxOccurs for "+itemName, maxOccurs, definition.getMaxOccurs()); }