@Test public void test910TypeWrongCompat() throws Exception { final String TEST_NAME = "test900TypeWrong"; String fileName = TEST_DIR + "/" + TEST_NAME + ".xml"; QueryType jaxb = toQueryTypeCompat(FileUtils.readFileToString(new File(fileName))); displayQueryType(jaxb); try { ObjectQuery query = toObjectQuery(ObjectType.class, jaxb); displayQuery(query); fail("Unexpected success!"); } catch (SchemaException e) { System.out.println("Got expected exception: " + e.getMessage()); } }
private void checkQuery(Class<? extends Containerable> objectClass, ObjectQuery q1object, String q2xml) throws Exception { // step 1 (serialization of Q1 + comparison) displayText("Query 1:"); displayQuery(q1object); QueryType q1jaxb = toQueryType(q1object); displayQueryType(q1jaxb); String q1xml = toXml(q1jaxb); displayQueryXml(q1xml); // XMLAssert.assertXMLEqual("Serialized query is not correct: Expected:\n" + q2xml + "\n\nReal:\n" + q1xml, q2xml, q1xml); // step 2 (parsing of Q2 + comparison) displayText("Query 2:"); displayQueryXml(q2xml); QueryType q2jaxb = toQueryType(q2xml); displayQueryType(q2jaxb); ObjectQuery q2object = toObjectQuery(objectClass, q2jaxb); assertEquals("Reparsed query is not as original one (via toString)", q1object.toString(), q2object.toString()); // primitive way of comparing parsed queries assertTrue("Reparsed query is not as original one (via equivalent):\nq1="+q1object+"\nq2="+q2object, q1object.equivalent(q2object)); }
@Test public void testFilterNotInOid() throws Exception { displayTestTitle("testFilterNotInOid"); SearchFilterType filterType = PrismTestUtil.parseAnyValue(FILTER_NOT_IN_OID); ObjectQuery query = toObjectQuery(UserType.class, filterType); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); assertTrue("Filter is not of NOT type", filter instanceof NotFilter); ObjectFilter subFilter = ((NotFilter) filter).getFilter(); assertTrue("Subfilter is not of IN_OID type", subFilter instanceof InOidFilter); QueryType convertedQueryType = toQueryType(query); System.out.println("Re-converted query type"); System.out.println(convertedQueryType.debugDump()); Element filterClauseElement = convertedQueryType.getFilter().getFilterClauseAsElement(getPrismContext()); LOGGER.info(convertedQueryType.getFilter().getFilterClauseXNode().debugDump()); System.out.println("Serialized filter (JAXB->DOM)"); String filterAsString = DOMUtil.serializeDOMToString(filterClauseElement); System.out.println(filterAsString); LOGGER.info(filterAsString); DomAsserts.assertElementQName(filterClauseElement, new QName(PrismConstants.NS_QUERY, "not")); assertEquals("wrong # of inOid subfilters", 1, filterClauseElement.getElementsByTagNameNS(PrismConstants.NS_QUERY, "inOid").getLength()); assertEquals("wrong # of value subfilters", 4, filterClauseElement.getElementsByTagNameNS(PrismConstants.NS_QUERY, "value").getLength()); }
@Test public void test430OrgFilterDefaultScope() throws Exception { final String TEST_NAME = "test430OrgFilterDefaultScope"; displayTestTitle(TEST_NAME); // default scope is SUBTREE String queryXml = "<?xml version='1.0'?><query><filter><org>\n" + " <orgRef>\n" + " <oid>333</oid>\n" + " </orgRef>\n" + " </org></filter></query>"; QueryType queryJaxb = toQueryType(queryXml); displayQueryType(queryJaxb); ObjectQuery query = toObjectQuery(OrgType.class, queryJaxb); displayQuery(query); ObjectQuery expectedQuery = getPrismContext().queryFor(OrgType.class).isChildOf("333").build(); assertEquals("Parsed query is wrong", expectedQuery.toString(), query.toString()); // primitive way of comparing queries // now reserialize the parsed query and compare with XML - the XML contains explicit scope=SUBTREE (as this is set when parsing original queryXml) checkQueryRoundtripFile(OrgType.class, query, TEST_NAME); }
@Test public void testFilterNotFullText() throws Exception { displayTestTitle("testFilterNotFullText"); SearchFilterType filterType = PrismTestUtil.parseAnyValue(FILTER_NOT_FULL_TEXT); ObjectQuery query = toObjectQuery(UserType.class, filterType); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); assertTrue("Filter is not of NOT type", filter instanceof NotFilter); ObjectFilter subFilter = ((NotFilter) filter).getFilter(); assertTrue("Subfilter is not of FULL_TEXT type", subFilter instanceof FullTextFilter); QueryType convertedQueryType = toQueryType(query); System.out.println("Re-converted query type"); System.out.println(convertedQueryType.debugDump()); Element filterClauseElement = convertedQueryType.getFilter().getFilterClauseAsElement(getPrismContext()); LOGGER.info(convertedQueryType.getFilter().getFilterClauseXNode().debugDump()); System.out.println("Serialized filter (JAXB->DOM)"); String filterAsString = DOMUtil.serializeDOMToString(filterClauseElement); System.out.println(filterAsString); LOGGER.info(filterAsString); DomAsserts.assertElementQName(filterClauseElement, new QName(PrismConstants.NS_QUERY, "not")); assertEquals("wrong # of fullText subfilters", 1, filterClauseElement.getElementsByTagNameNS(PrismConstants.NS_QUERY, "fullText").getLength()); assertEquals("wrong # of value subfilters", 2, filterClauseElement.getElementsByTagNameNS(PrismConstants.NS_QUERY, "value").getLength()); }
@Test public void testConnectorQuery() throws Exception { displayTestTitle("testConnectorQuery"); SearchFilterType filterType = PrismTestUtil.parseAtomicValue(FILTER_CONNECTOR_BY_TYPE_FILE, SearchFilterType.COMPLEX_TYPE); ObjectQuery query; try { query = getQueryConverter().createObjectQuery(ConnectorType.class, filterType); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); PrismAsserts.assertEqualsFilter(query.getFilter(), ConnectorType.F_CONNECTOR_TYPE, DOMUtil.XSD_STRING, ConnectorType.F_CONNECTOR_TYPE); PrismAsserts.assertEqualsFilterValue((EqualFilter) filter, "org.identityconnectors.ldap.LdapConnector"); QueryType convertedQueryType = toQueryType(query); displayQueryType(convertedQueryType); } catch (Exception ex) { LOGGER.error("Error while converting query: {}", ex.getMessage(), ex); throw ex; } }
@Test public void testFilterTypeUserNone() throws Exception { displayTestTitle("testFilterTypeUserNone"); SearchFilterType filterType = PrismTestUtil.parseAnyValue(FILTER_TYPE_USER_NONE); ObjectQuery query = toObjectQuery(UserType.class, filterType); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); assertTrue("Filter is not of TYPE type", filter instanceof TypeFilter); ObjectFilter subFilter = ((TypeFilter) filter).getFilter(); assertTrue("Filter is not of NONE type", subFilter instanceof NoneFilter); QueryType convertedQueryType = toQueryType(query); System.out.println("Re-converted query type"); System.out.println(convertedQueryType.debugDump()); Element filterClauseElement = convertedQueryType.getFilter().getFilterClauseAsElement(getPrismContext()); LOGGER.info(convertedQueryType.getFilter().getFilterClauseXNode().debugDump()); System.out.println("Serialized filter (JAXB->DOM)"); String filterAsString = DOMUtil.serializeDOMToString(filterClauseElement); System.out.println(filterAsString); LOGGER.info(filterAsString); DomAsserts.assertElementQName(filterClauseElement, new QName(PrismConstants.NS_QUERY, "type")); }
@Test public void testGenericQuery() throws Exception { displayTestTitle("testGenericQuery"); SearchFilterType queryType = unmarshalFilter(FILTER_AND_GENERIC_FILE); ObjectQuery query = toObjectQuery(GenericObjectType.class, queryType); displayQuery(query); // check parent filter assertNotNull(query); ObjectFilter filter = query.getFilter(); PrismAsserts.assertAndFilter(filter, 2); // check first condition ObjectFilter first = getFilterCondition(filter, 0); PrismAsserts.assertEqualsFilter(first, GenericObjectType.F_NAME, PolyStringType.COMPLEX_TYPE, GenericObjectType.F_NAME); PrismAsserts.assertEqualsFilterValue((EqualFilter) first, createPolyString("generic object")); // check second condition ObjectFilter second = getFilterCondition(filter, 1); PrismAsserts.assertEqualsFilter(second, intExtensionDefinition, DOMUtil.XSD_INT, ItemPath.create( ObjectType.F_EXTENSION, new QName(NS_EXTENSION, "intType"))); PrismAsserts.assertEqualsFilterValue((EqualFilter) second, 123); QueryType convertedQueryType = toQueryType(query); assertNotNull("Re-serialized query is null ", convertedQueryType); assertNotNull("Filter in re-serialized query must not be null.", convertedQueryType.getFilter()); displayQueryType(convertedQueryType); }
@Test public void testFilterUserNameJaxb() throws Exception { displayTestTitle("testFilterUserNameJaxb"); SearchFilterType filterType = PrismTestUtil.parseAnyValue(FILTER_USER_NAME_FILE); ObjectQuery query = toObjectQuery(UserType.class, filterType); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); PrismAsserts.assertEqualsFilter(filter, UserType.F_NAME, PolyStringType.COMPLEX_TYPE, ItemPath.create(new QName(null, UserType.F_NAME.getLocalPart()))); PrismAsserts.assertEqualsFilterValue((EqualFilter) filter, createPolyString("jack")); QueryType convertedQueryType = toQueryType(query); System.out.println("Re-converted query type"); System.out.println(convertedQueryType.debugDump()); Element filterClauseElement = convertedQueryType.getFilter().getFilterClauseAsElement(getPrismContext()); System.out.println("Serialized filter (JAXB->DOM)"); System.out.println(DOMUtil.serializeDOMToString(filterClauseElement)); DomAsserts.assertElementQName(filterClauseElement, EqualFilter.ELEMENT_NAME); DomAsserts.assertSubElements(filterClauseElement, 2); DomAsserts.assertSubElement(filterClauseElement, PrismConstants.Q_VALUE); Element valueElement = DOMUtil.getChildElement(filterClauseElement, PrismConstants.Q_VALUE); DomAsserts.assertTextContent(valueElement, "jack"); }
try { query = getQueryConverter().createObjectQuery(ConnectorType.class, filterType); displayQuery(query);
@Test public void testAccountQueryAttributesAndResourceNoNs() throws Exception { displayTestTitle("testAccountQueryAttributesAndResourceNoNs"); SearchFilterType filterType = unmarshalFilter(FILTER_ACCOUNT_ATTRIBUTES_RESOURCE_REF_NO_NS_FILE); ObjectQuery query = toObjectQuery(ShadowType.class, filterType); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); PrismAsserts.assertAndFilter(filter, 2); ObjectFilter first = getFilterCondition(filter, 0); PrismAsserts.assertRefFilter(first, ShadowType.F_RESOURCE_REF, ObjectReferenceType.COMPLEX_TYPE, ShadowType.F_RESOURCE_REF); assertRefFilterValue((RefFilter) first, "aae7be60-df56-11df-8608-0002a5d5c51b"); ObjectFilter second = getFilterCondition(filter, 1); PrismAsserts.assertEqualsFilter(second, ICF_NAME, DOMUtil.XSD_STRING, ItemPath.create("attributes", "name")); //PrismAsserts.assertEqualsFilterValue((EqualFilter) second, "uid=jbond,ou=People,dc=example,dc=com"); QueryType convertedQueryType = toQueryType(query); System.out.println(DOMUtil.serializeDOMToString(convertedQueryType.getFilter().getFilterClauseAsElement(getPrismContext()))); // TODO: add some asserts }
@Test public void testAccountQueryAttributesAndResource() throws Exception { displayTestTitle("testAccountQueryAttributesAndResource"); SearchFilterType filterType = unmarshalFilter(FILTER_ACCOUNT_ATTRIBUTES_RESOURCE_REF_FILE); ObjectQuery query = toObjectQuery(ShadowType.class, filterType); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); PrismAsserts.assertAndFilter(filter, 2); ObjectFilter first = getFilterCondition(filter, 0); PrismAsserts.assertRefFilter(first, ShadowType.F_RESOURCE_REF, ObjectReferenceType.COMPLEX_TYPE, ShadowType.F_RESOURCE_REF); assertRefFilterValue((RefFilter) first, "aae7be60-df56-11df-8608-0002a5d5c51b"); ObjectFilter second = getFilterCondition(filter, 1); PrismAsserts.assertEqualsFilter(second, ICF_NAME, DOMUtil.XSD_STRING, ItemPath.create(ShadowType.F_ATTRIBUTES, ICF_NAME)); PrismAsserts.assertEqualsFilterValue((EqualFilter) second, "uid=jbond,ou=People,dc=example,dc=com"); QueryType convertedQueryType = toQueryType(query); LOGGER.info(DOMUtil.serializeDOMToString(convertedQueryType.getFilter().getFilterClauseAsElement(getPrismContext()))); // TODO: add some asserts }
@Test public void testAccountQueryCompositeOr() throws Exception { displayTestTitle("testAccountQueryCompositeOr"); SearchFilterType filterType = unmarshalFilter(FILTER_OR_COMPOSITE); ObjectQuery query = toObjectQuery(ShadowType.class, filterType); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); PrismAsserts.assertOrFilter(filter, 4); ObjectFilter first = getFilterCondition(filter, 0); PrismAsserts.assertEqualsFilter(first, ShadowType.F_INTENT, DOMUtil.XSD_STRING, ShadowType.F_INTENT); PrismAsserts.assertEqualsFilterValue((EqualFilter) first, "some account type"); ObjectFilter second = getFilterCondition(filter, 1); PrismAsserts.assertEqualsFilter(second, fooBlaDefinition, DOMUtil.XSD_STRING, ItemPath.create( ShadowType.F_ATTRIBUTES, fooBlaDefinition)); PrismAsserts.assertEqualsFilterValue((EqualFilter) second, "foo value"); ObjectFilter third = getFilterCondition(filter, 2); PrismAsserts.assertEqualsFilter(third, stringExtensionDefinition, DOMUtil.XSD_STRING, ItemPath.create( ShadowType.F_EXTENSION, stringExtensionDefinition)); PrismAsserts.assertEqualsFilterValue((EqualFilter) third, "uid=test,dc=example,dc=com"); ObjectFilter forth = getFilterCondition(filter, 3); PrismAsserts.assertRefFilter(forth, ShadowType.F_RESOURCE_REF, ObjectReferenceType.COMPLEX_TYPE, ShadowType.F_RESOURCE_REF); assertRefFilterValue((RefFilter) forth, "d0db5be9-cb93-401f-b6c1-86ffffe4cd5e"); QueryType convertedQueryType = toQueryType(query); LOGGER.info(DOMUtil.serializeDOMToString(convertedQueryType.getFilter().getFilterClauseAsElement(getPrismContext()))); // TODO: add some asserts }