Java tutorial
/* * Copyright (c) 2010-2013 Evolveum * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.evolveum.midpoint.schema; import static com.evolveum.midpoint.prism.util.PrismTestUtil.*; import static org.testng.AssertJUnit.*; import java.io.File; import java.io.IOException; import java.util.List; import javax.xml.namespace.QName; import com.evolveum.midpoint.prism.PrismContext; import com.evolveum.midpoint.prism.parser.DomParser; import com.evolveum.midpoint.prism.parser.QueryConvertor; import com.evolveum.midpoint.prism.query.OrgFilter; import com.evolveum.midpoint.prism.query.builder.QueryBuilder; import com.evolveum.midpoint.prism.util.PrismTestUtil; import com.evolveum.midpoint.prism.util.PrismUtil; import com.evolveum.midpoint.prism.xnode.RootXNode; import com.evolveum.midpoint.xml.ns._public.common.common_3.OrgType; import org.apache.commons.lang.StringUtils; import org.testng.annotations.BeforeSuite; import org.testng.annotations.Test; import org.w3c.dom.Element; import org.xml.sax.SAXException; import com.evolveum.midpoint.prism.PrismConstants; import com.evolveum.midpoint.prism.PrismObjectDefinition; import com.evolveum.midpoint.prism.PrismPropertyDefinition; import com.evolveum.midpoint.prism.PrismPropertyValue; import com.evolveum.midpoint.prism.PrismReferenceValue; import com.evolveum.midpoint.prism.PrismValue; import com.evolveum.midpoint.prism.path.ItemPath; import com.evolveum.midpoint.prism.query.AndFilter; import com.evolveum.midpoint.prism.query.EqualFilter; import com.evolveum.midpoint.prism.query.LogicalFilter; import com.evolveum.midpoint.prism.query.NaryLogicalFilter; import com.evolveum.midpoint.prism.query.ObjectFilter; import com.evolveum.midpoint.prism.query.ObjectPaging; import com.evolveum.midpoint.prism.query.ObjectQuery; import com.evolveum.midpoint.prism.query.OrFilter; import com.evolveum.midpoint.prism.query.QueryJaxbConvertor; import com.evolveum.midpoint.prism.query.RefFilter; import com.evolveum.midpoint.prism.query.TypeFilter; import com.evolveum.midpoint.prism.util.PrismAsserts; import com.evolveum.midpoint.prism.xnode.ListXNode; import com.evolveum.midpoint.prism.xnode.MapXNode; import com.evolveum.midpoint.schema.constants.MidPointConstants; import com.evolveum.midpoint.util.DOMUtil; import com.evolveum.midpoint.util.DomAsserts; import com.evolveum.midpoint.util.PrettyPrinter; import com.evolveum.midpoint.util.exception.SchemaException; import com.evolveum.midpoint.util.logging.Trace; import com.evolveum.midpoint.util.logging.TraceManager; import com.evolveum.midpoint.xml.ns._public.common.common_3.ConnectorType; import com.evolveum.midpoint.xml.ns._public.common.common_3.FailedOperationTypeType; import com.evolveum.midpoint.xml.ns._public.common.common_3.GenericObjectType; import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType; import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectType; import com.evolveum.midpoint.xml.ns._public.common.common_3.ShadowType; import com.evolveum.midpoint.xml.ns._public.common.common_3.UserType; import com.evolveum.prism.xml.ns._public.query_3.PagingType; import com.evolveum.prism.xml.ns._public.query_3.QueryType; import com.evolveum.prism.xml.ns._public.query_3.SearchFilterType; import com.evolveum.prism.xml.ns._public.types_3.PolyStringType; public class TestQueryConvertor { private static final Trace LOGGER = TraceManager.getTrace(TestQueryConvertor.class); private static final File TEST_DIR = new File("src/test/resources/queryconvertor"); private static final String NS_EXTENSION = "http://midpoint.evolveum.com/xml/ns/test/extension"; private static final String NS_ICFS = "http://midpoint.evolveum.com/xml/ns/public/connector/icf-1/resource-schema-3"; private static final String NS_BLA = "http://midpoint.evolveum.com/blabla"; private static final QName intExtensionDefinition = new QName(NS_EXTENSION, "intType"); private static final QName stringExtensionDefinition = new QName(NS_EXTENSION, "stringType"); private static final QName fooBlaDefinition = new QName(NS_BLA, "foo"); private static final QName ICF_NAME = new QName(NS_ICFS, "name"); private static final QName FAILED_OPERATION_TYPE_QNAME = new QName(SchemaConstantsGenerated.NS_COMMON, "FailedOperationTypeType"); private static final File FILTER_AND_GENERIC_FILE = new File(TEST_DIR, "filter-and-generic.xml"); private static final File FILTER_ACCOUNT_FILE = new File(TEST_DIR, "filter-account.xml"); private static final File FILTER_ACCOUNT_ATTRIBUTES_RESOURCE_REF_FILE = new File(TEST_DIR, "filter-account-by-attributes-and-resource-ref.xml"); private static final File FILTER_OR_COMPOSITE = new File(TEST_DIR, "filter-or-composite.xml"); private static final File FILTER_CONNECTOR_BY_TYPE_FILE = new File(TEST_DIR, "filter-connector-by-type.xml"); private static final File FILTER_BY_TYPE_FILE = new File(TEST_DIR, "filter-by-type.xml"); @BeforeSuite public void setup() throws SchemaException, SAXException, IOException { PrettyPrinter.setDefaultNamespacePrefix(MidPointConstants.NS_MIDPOINT_PUBLIC_PREFIX); resetPrismContext(MidPointPrismContextFactory.FACTORY); } @Test public void testAccountFilter() throws Exception { displayTestTitle("testAccountFilter"); SearchFilterType filterType = unmarshalFilter(FILTER_ACCOUNT_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.assertEqualsFilter(first, ShadowType.F_FAILED_OPERATION_TYPE, FAILED_OPERATION_TYPE_QNAME, new ItemPath(ShadowType.F_FAILED_OPERATION_TYPE)); PrismAsserts.assertEqualsFilterValue((EqualFilter) first, FailedOperationTypeType.ADD); ObjectFilter second = getFilterCondition(filter, 1); PrismAsserts.assertEqualsFilter(second, ShadowType.F_NAME, PolyStringType.COMPLEX_TYPE, new ItemPath(ShadowType.F_NAME)); PrismAsserts.assertEqualsFilterValue((EqualFilter) second, createPolyString("someName")); QueryType convertedQueryType = toQueryType(query); System.out.println("Re-converted query type"); System.out.println(convertedQueryType.debugDump()); SearchFilterType convertedFilterType = convertedQueryType.getFilter(); MapXNode xFilter = convertedFilterType.serializeToXNode(); PrismAsserts.assertSize(xFilter, 1); PrismAsserts.assertSubnode(xFilter, AndFilter.ELEMENT_NAME, MapXNode.class); MapXNode xandmap = (MapXNode) xFilter.get(AndFilter.ELEMENT_NAME); PrismAsserts.assertSize(xandmap, 1); PrismAsserts.assertSubnode(xandmap, EqualFilter.ELEMENT_NAME, ListXNode.class); ListXNode xequalsList = (ListXNode) xandmap.get(EqualFilter.ELEMENT_NAME); PrismAsserts.assertSize(xequalsList, 2); Element filterClauseElement = convertedFilterType.getFilterClauseAsElement(); System.out.println("Serialized filter (JAXB->DOM)"); System.out.println(DOMUtil.serializeDOMToString(filterClauseElement)); DomAsserts.assertElementQName(filterClauseElement, AndFilter.ELEMENT_NAME); DomAsserts.assertSubElements(filterClauseElement, 2); Element firstSubelement = DOMUtil.getChildElement(filterClauseElement, 0); DomAsserts.assertElementQName(firstSubelement, EqualFilter.ELEMENT_NAME); Element firstValueElement = DOMUtil.getChildElement(firstSubelement, PrismConstants.Q_VALUE); DomAsserts.assertTextContent(firstValueElement, "add"); Element secondSubelement = DOMUtil.getChildElement(filterClauseElement, 1); DomAsserts.assertElementQName(secondSubelement, EqualFilter.ELEMENT_NAME); Element secondValueElement = DOMUtil.getChildElement(secondSubelement, PrismConstants.Q_VALUE); DomAsserts.assertTextContent(secondValueElement, "someName"); } @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, new ItemPath(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, new ItemPath(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())); // 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, new ItemPath(ShadowType.F_INTENT)); PrismAsserts.assertEqualsFilterValue((EqualFilter) first, "some account type"); ObjectFilter second = getFilterCondition(filter, 1); PrismAsserts.assertEqualsFilter(second, fooBlaDefinition, DOMUtil.XSD_STRING, new ItemPath(ShadowType.F_ATTRIBUTES, fooBlaDefinition)); PrismAsserts.assertEqualsFilterValue((EqualFilter) second, "foo value"); ObjectFilter third = getFilterCondition(filter, 2); PrismAsserts.assertEqualsFilter(third, stringExtensionDefinition, DOMUtil.XSD_STRING, new ItemPath(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, new ItemPath(ShadowType.F_RESOURCE_REF)); assertRefFilterValue((RefFilter) forth, "d0db5be9-cb93-401f-b6c1-86ffffe4cd5e"); QueryType convertedQueryType = toQueryType(query); LOGGER.info(DOMUtil.serializeDOMToString(convertedQueryType.getFilter().getFilterClauseAsElement())); // TODO: add some asserts } @Test public void testConnectorQuery() throws Exception { displayTestTitle("testConnectorQuery"); SearchFilterType filterType = PrismTestUtil.parseAtomicValue(FILTER_CONNECTOR_BY_TYPE_FILE, SearchFilterType.COMPLEX_TYPE); ObjectQuery query = null; try { query = QueryJaxbConvertor.createObjectQuery(ConnectorType.class, filterType, getPrismContext()); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); PrismAsserts.assertEqualsFilter(query.getFilter(), ConnectorType.F_CONNECTOR_TYPE, DOMUtil.XSD_STRING, new ItemPath(ConnectorType.F_CONNECTOR_TYPE)); PrismAsserts.assertEqualsFilterValue((EqualFilter) filter, "org.identityconnectors.ldap.LdapConnector"); QueryType convertedQueryType = toQueryType(query); displayQueryType(convertedQueryType); } catch (SchemaException ex) { LOGGER.error("Error while converting query: {}", ex.getMessage(), ex); throw ex; } catch (RuntimeException ex) { LOGGER.error("Error while converting query: {}", ex.getMessage(), ex); throw ex; } catch (Exception ex) { LOGGER.error("Error while converting query: {}", ex.getMessage(), ex); throw ex; } } private PrismObjectDefinition<UserType> getUserDefinition() { return getPrismContext().getSchemaRegistry().findObjectDefinitionByCompileTimeClass(UserType.class); } @Test public void testTypeFilterQuery() throws Exception { displayTestTitle("testConnectorQuery"); SearchFilterType filterType = PrismTestUtil.parseAtomicValue(FILTER_BY_TYPE_FILE, SearchFilterType.COMPLEX_TYPE); ObjectQuery query = null; try { query = QueryJaxbConvertor.createObjectQuery(ConnectorType.class, filterType, getPrismContext()); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); assertTrue("filter is not an instance of type filter", filter instanceof TypeFilter); TypeFilter typeFilter = (TypeFilter) filter; assertEquals(typeFilter.getType(), UserType.COMPLEX_TYPE); assertNotNull("filter in type filter must not be null", typeFilter.getFilter()); ItemPath namePath = new ItemPath(UserType.F_NAME); PrismPropertyDefinition ppd = getUserDefinition().findPropertyDefinition(namePath); PrismAsserts.assertEqualsFilter(typeFilter.getFilter(), ppd.getName(), ppd.getTypeName(), namePath); PrismAsserts.assertEqualsFilterValue((EqualFilter) typeFilter.getFilter(), PrismTestUtil.createPolyString("some name identificator")); // PrismAsserts.assertEqualsFilter(query.getFilter(), ConnectorType.F_CONNECTOR_TYPE, DOMUtil.XSD_STRING, // new ItemPath(ConnectorType.F_CONNECTOR_TYPE)); // PrismAsserts.assertEqualsFilterValue((EqualsFilter) filter, "org.identityconnectors.ldap.LdapConnector"); QueryType convertedQueryType = toQueryType(query); displayQueryType(convertedQueryType); } catch (SchemaException ex) { LOGGER.error("Error while converting query: {}", ex.getMessage(), ex); throw ex; } catch (RuntimeException ex) { LOGGER.error("Error while converting query: {}", ex.getMessage(), ex); throw ex; } catch (Exception ex) { LOGGER.error("Error while converting query: {}", ex.getMessage(), ex); throw ex; } } private void assertRefFilterValue(RefFilter filter, String oid) { List<? extends PrismValue> values = filter.getValues(); assertEquals(1, values.size()); assertEquals(PrismReferenceValue.class, values.get(0).getClass()); PrismReferenceValue val = (PrismReferenceValue) values.get(0); assertEquals(oid, val.getOid()); // TODO: maybe some more asserts for type, relation and other reference // values } private ObjectQuery toObjectQuery(Class type, QueryType queryType) throws Exception { ObjectQuery query = QueryJaxbConvertor.createObjectQuery(type, queryType, getPrismContext()); return query; } private ObjectQuery toObjectQuery(Class type, SearchFilterType filterType) throws Exception { ObjectQuery query = QueryJaxbConvertor.createObjectQuery(type, filterType, getPrismContext()); return query; } private QueryType toQueryType(ObjectQuery query) throws Exception { return QueryJaxbConvertor.createQueryType(query, getPrismContext()); } @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, new ItemPath(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, new ItemPath(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 testUserQuery() throws Exception { displayTestTitle("testUserQuery"); File[] userQueriesToTest = new File[] { new File(TEST_DIR, "filter-user-by-fullName.xml"), new File(TEST_DIR, "filter-user-by-name.xml"), new File(TEST_DIR, "filter-user-substring-fullName.xml") }; // prismContext.silentMarshalObject(queryTypeNew, LOGGER); for (File file : userQueriesToTest) { SearchFilterType filterType = PrismTestUtil.parseAtomicValue(file, SearchFilterType.COMPLEX_TYPE); LOGGER.info("===[ query type parsed ]==="); ObjectQuery query = null; try { query = QueryJaxbConvertor.createObjectQuery(UserType.class, filterType, getPrismContext()); LOGGER.info("query converted: "); LOGGER.info("QUERY DUMP: {}", query.debugDump()); LOGGER.info("QUERY Pretty print: {}", query.toString()); System.out.println("QUERY Pretty print: " + query.toString()); QueryType convertedQueryType = QueryJaxbConvertor.createQueryType(query, getPrismContext()); LOGGER.info( DOMUtil.serializeDOMToString(convertedQueryType.getFilter().getFilterClauseAsElement())); } catch (SchemaException ex) { LOGGER.error("Error while converting query: {}", ex.getMessage(), ex); throw ex; } catch (RuntimeException ex) { LOGGER.error("Error while converting query: {}", ex.getMessage(), ex); throw ex; } catch (Exception ex) { LOGGER.error("Error while converting query: {}", ex.getMessage(), ex); throw ex; } } } @Test public void testConvertQueryNullFilter() throws Exception { ObjectQuery query = ObjectQuery.createObjectQuery(ObjectPaging.createPaging(0, 10)); QueryType queryType = QueryJaxbConvertor.createQueryType(query, getPrismContext()); assertNotNull(queryType); assertNull(queryType.getFilter()); PagingType paging = queryType.getPaging(); assertNotNull(paging); assertEquals(new Integer(0), paging.getOffset()); assertEquals(new Integer(10), paging.getMaxSize()); } @Test public void test100OrgFilterRoot() throws Exception { displayTestTitle("test100OrgFilterRoot"); ObjectQuery query = QueryBuilder.queryFor(OrgType.class, getPrismContext()).isRoot().build(); String expected = "<q:org> <q:isRoot>true</q:isRoot> </q:org>"; checkQuery(query, expected); } protected void checkQuery(ObjectQuery query, String expected) throws Exception { displayQuery(query); QueryType queryType = toQueryType(query); displayQueryType(queryType); assertXml(queryType, expected); ObjectQuery query2 = toObjectQuery(OrgType.class, queryType); displayQuery(query2); // primitive way of comparing queries assertEquals("Reparsed query is not as original one", query.toString(), query2.toString()); QueryType queryType2 = toQueryType(query2); displayQueryType(queryType2); assertEquals("Reserialized query type is not as original one", queryType, queryType2); } @Test public void test110OrgFilterSubtree() throws Exception { displayTestTitle("test110OrgFilterSubtree"); ObjectQuery query = QueryBuilder.queryFor(OrgType.class, getPrismContext()).isChildOf("111").build(); displayQuery(query); String expected = "<q:org>\n" + " <q:orgRef>\n" + " <q:oid>111</q:oid>\n" + " </q:orgRef>\n" + " <q:scope>SUBTREE</q:scope>\n" + " </q:org>"; checkQuery(query, expected); } @Test public void test120OrgFilterDirect() throws Exception { displayTestTitle("test120OrgFilterDirect"); ObjectQuery query = QueryBuilder.queryFor(OrgType.class, getPrismContext()).isDirectChildOf("222").build(); displayQuery(query); String expected = "<q:org>\n" + " <q:orgRef>\n" + " <q:oid>222</q:oid>\n" + " </q:orgRef>\n" + " <q:scope>ONE_LEVEL</q:scope>\n" + " </q:org>"; checkQuery(query, expected); } @Test public void test130OrgFilterDefaultScope() throws Exception { displayTestTitle("test130OrgFilterDefaultScope"); String filterText = "<?xml version='1.0'?><filter><org>\n" + " <orgRef>\n" + " <oid>333</oid>\n" + " </orgRef>\n" + " </org></filter>"; SearchFilterType filterType = getPrismContext().parseAtomicValue(filterText, SearchFilterType.COMPLEX_TYPE, PrismContext.LANG_XML); displaySearchFilterType(filterType); ObjectFilter filter = QueryConvertor.parseFilter(filterType, OrgType.class, getPrismContext()); ObjectQuery query = ObjectQuery.createObjectQuery(filter); ObjectQuery expectedQuery = QueryBuilder.queryFor(OrgType.class, getPrismContext()).isChildOf("333") .build(); // primitive way of comparing queries assertEquals("Parsed query is wrong", expectedQuery.toString(), query.toString()); // now reserialize the parsed query and compare with XML String expected = "<q:org>\n" + " <q:orgRef>\n" + " <q:oid>333</q:oid>\n" + " </q:orgRef>\n" + " <q:scope>SUBTREE</q:scope>\n" + " </q:org>"; checkQuery(query, expected); } private void assertXml(QueryType queryType, String expected) throws SchemaException { MapXNode mapXNode = queryType.getFilter().getFilterClauseXNode(); String realWrapped = getPrismContext().serializeXNodeToString(new RootXNode(new QName("query"), mapXNode), PrismContext.LANG_XML); // primitive but effective method int start = realWrapped.indexOf('>') + 1; int end = realWrapped.lastIndexOf('<'); String real = realWrapped.substring(start, end); String expNorm = StringUtils.normalizeSpace(expected); String realNorm = StringUtils.normalizeSpace(real); if (!expNorm.equals(realNorm)) { String m = "Serialized query is not correct. Expected:\n" + expected + "\nActual:\n" + real + "\n\nNormalized versions:\n\n" + "Expected: " + expNorm + "\nActual: " + realNorm + "\n"; LOGGER.error("{}", m); throw new AssertionError(m); } } }